« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 6621
- compare with another revision
- download diff
- download tarball
- view history from revision 6621
- Committer: Tarmac
- Author(s): Vincent Ladeuil
- Date: 2017-01-30 14:42:05 UTC
- mfrom: (6620.1.1 trunk)
- Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge 2.7 into trunk including fix for bug #1657238 [r=vila]
- files added:
- NEWS
- bzrlib/branchfmt
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/grep
- bzrlib/plugins/po_merge
- bzrlib/plugins/po_merge/tests
- bzrlib/plugins/weave_fmt
- bzrlib/plugins/weave_fmt/tests
- bzrlib/tests/per_bzrdir
- bzrlib/tests/per_controldir_colo
- bzrlib/tests/per_repository_vf
- po
- files removed:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- files renamed:
- contrib/apport/ => apport/
- contrib/apport/bzr.conf => apport/bzr-crashdb.conf
- bzrlib/sign_my_commits.py => bzrlib/commit_signature_commands.py
- bzrlib/doc_generate/sphinx_conf.py => bzrlib/doc_generate/conf.py
- bzrlib/repofmt/weaverepo.py => bzrlib/plugins/weave_fmt/repository.py
- bzrlib/xml4.py => bzrlib/plugins/weave_fmt/xml4.py
- bzrlib/tests/per_bzrdir/ => bzrlib/tests/per_controldir/
- bzrlib/tests/per_bzrdir/test_bzrdir.py => bzrlib/tests/per_controldir/test_controldir.py
- bzrlib/tests/per_repository/test_is_write_locked.py => bzrlib/tests/per_repository/test_locking.py
- bzrlib/tests/per_repository/helpers.py => bzrlib/tests/per_repository_vf/helpers.py
- bzrlib/tests/per_repository/test__generate_text_key_index.py => bzrlib/tests/per_repository_vf/test__generate_text_key_index.py
- bzrlib/tests/per_repository/test_add_inventory_by_delta.py => bzrlib/tests/per_repository_vf/test_add_inventory_by_delta.py
- bzrlib/tests/per_repository/test_check_reconcile.py => bzrlib/tests/per_repository_vf/test_check_reconcile.py
- bzrlib/tests/per_repository/test_find_text_key_references.py => bzrlib/tests/per_repository_vf/test_find_text_key_references.py
- bzrlib/tests/per_repository/test_merge_directive.py => bzrlib/tests/per_repository_vf/test_merge_directive.py
- NEWS => doc/en/release-notes/bzr-2.3.txt
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2005-2010 Canonical Ltd
1
# Copyright (C) 2005-2012 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
17
17
"""builtin bzr commands"""
18
18
19
from __future__ import absolute_import
20
19
21
import os
20
22
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
23
import bzrlib.bzrdir
24
25
from bzrlib import lazy_import
26
lazy_import.lazy_import(globals(), """
24
27
import cStringIO
28
import errno
25
29
import sys
26
30
import time
27
31
30
34
bugtracker,
31
35
bundle,
32
36
btree_index,
33
bzrdir,
37
controldir,
34
38
directory_service,
35
39
delta,
36
config,
40
config as _mod_config,
37
41
errors,
38
42
globbing,
39
43
hooks,
45
49
rename_map,
46
50
revision as _mod_revision,
47
51
static_tuple,
48
symbol_versioning,
49
52
timestamp,
50
53
transport,
51
54
ui,
52
55
urlutils,
53
56
views,
57
gpg,
54
58
)
55
59
from bzrlib.branch import Branch
56
60
from bzrlib.conflicts import ConflictList
58
62
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
59
63
from bzrlib.smtp_connection import SMTPConnection
60
64
from bzrlib.workingtree import WorkingTree
65
from bzrlib.i18n import gettext, ngettext
61
66
""")
62
67
63
from bzrlib.commands import Command, display_command
68
from bzrlib.commands import (
69
Command,
70
builtin_command_registry,
71
display_command,
72
)
64
73
from bzrlib.option import (
65
74
ListOption,
66
75
Option,
69
78
_parse_revision_str,
70
79
)
71
80
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
72
73
74
def tree_files(file_list, default_branch=u'.', canonicalize=True,
75
apply_view=True):
76
try:
77
return internal_tree_files(file_list, default_branch, canonicalize,
78
apply_view)
79
except errors.FileInWrongBranch, e:
80
raise errors.BzrCommandError("%s is not in the same branch as %s" %
81
(e.path, file_list[0]))
81
from bzrlib import (
82
symbol_versioning,
83
)
84
85
86
def _get_branch_location(control_dir, possible_transports=None):
87
"""Return location of branch for this control dir."""
88
try:
89
target = control_dir.get_branch_reference()
90
except errors.NotBranchError:
91
return control_dir.root_transport.base
92
if target is not None:
93
return target
94
this_branch = control_dir.open_branch(
95
possible_transports=possible_transports)
96
# This may be a heavy checkout, where we want the master branch
97
master_location = this_branch.get_bound_location()
98
if master_location is not None:
99
return master_location
100
# If not, use a local sibling
101
return this_branch.base
102
103
104
def _is_colocated(control_dir, possible_transports=None):
105
"""Check if the branch in control_dir is colocated.
106
107
:param control_dir: Control directory
108
:return: Tuple with boolean indicating whether the branch is colocated
109
and the full URL to the actual branch
110
"""
111
# This path is meant to be relative to the existing branch
112
this_url = _get_branch_location(control_dir,
113
possible_transports=possible_transports)
114
# Perhaps the target control dir supports colocated branches?
115
try:
116
root = controldir.ControlDir.open(this_url,
117
possible_transports=possible_transports)
118
except errors.NotBranchError:
119
return (False, this_url)
120
else:
121
try:
122
wt = control_dir.open_workingtree()
123
except (errors.NoWorkingTree, errors.NotLocalUrl):
124
return (False, this_url)
125
else:
126
return (
127
root._format.colocated_branches and
128
control_dir.control_url == root.control_url,
129
this_url)
130
131
132
def lookup_new_sibling_branch(control_dir, location, possible_transports=None):
133
"""Lookup the location for a new sibling branch.
134
135
:param control_dir: Control directory to find sibling branches from
136
:param location: Name of the new branch
137
:return: Full location to the new branch
138
"""
139
location = directory_service.directories.dereference(location)
140
if '/' not in location and '\\' not in location:
141
(colocated, this_url) = _is_colocated(control_dir, possible_transports)
142
143
if colocated:
144
return urlutils.join_segment_parameters(this_url,
145
{"branch": urlutils.escape(location)})
146
else:
147
return urlutils.join(this_url, '..', urlutils.escape(location))
148
return location
149
150
151
def open_sibling_branch(control_dir, location, possible_transports=None):
152
"""Open a branch, possibly a sibling of another.
153
154
:param control_dir: Control directory relative to which to lookup the
155
location.
156
:param location: Location to look up
157
:return: branch to open
158
"""
159
try:
160
# Perhaps it's a colocated branch?
161
return control_dir.open_branch(location,
162
possible_transports=possible_transports)
163
except (errors.NotBranchError, errors.NoColocatedBranchSupport):
164
this_url = _get_branch_location(control_dir)
165
return Branch.open(
166
urlutils.join(
167
this_url, '..', urlutils.escape(location)))
168
169
170
def open_nearby_branch(near=None, location=None, possible_transports=None):
171
"""Open a nearby branch.
172
173
:param near: Optional location of container from which to open branch
174
:param location: Location of the branch
175
:return: Branch instance
176
"""
177
if near is None:
178
if location is None:
179
location = "."
180
try:
181
return Branch.open(location,
182
possible_transports=possible_transports)
183
except errors.NotBranchError:
184
near = "."
185
cdir = controldir.ControlDir.open(near,
186
possible_transports=possible_transports)
187
return open_sibling_branch(cdir, location,
188
possible_transports=possible_transports)
189
190
191
def iter_sibling_branches(control_dir, possible_transports=None):
192
"""Iterate over the siblings of a branch.
193
194
:param control_dir: Control directory for which to look up the siblings
195
:return: Iterator over tuples with branch name and branch object
196
"""
197
seen_urls = set()
198
try:
199
reference = control_dir.get_branch_reference()
200
except errors.NotBranchError:
201
# There is no active branch, just return the colocated branches.
202
for name, branch in control_dir.get_branches().iteritems():
203
yield name, branch
204
return
205
if reference is not None:
206
ref_branch = Branch.open(reference,
207
possible_transports=possible_transports)
208
else:
209
ref_branch = None
210
if ref_branch is None or ref_branch.name:
211
if ref_branch is not None:
212
control_dir = ref_branch.bzrdir
213
for name, branch in control_dir.get_branches().iteritems():
214
yield name, branch
215
else:
216
repo = ref_branch.bzrdir.find_repository()
217
for branch in repo.find_branches(using=True):
218
name = urlutils.relative_url(repo.user_url,
219
branch.user_url).rstrip("/")
220
yield name, branch
82
221
83
222
84
223
def tree_files_for_add(file_list):
109
248
if view_files:
110
249
file_list = view_files
111
250
view_str = views.view_display_str(view_files)
112
note("Ignoring files outside view. View is %s" % view_str)
251
note(gettext("Ignoring files outside view. View is %s") % view_str)
113
252
return tree, file_list
114
253
115
254
117
256
if revisions is None:
118
257
return None
119
258
if len(revisions) != 1:
120
raise errors.BzrCommandError(
121
'bzr %s --revision takes exactly one revision identifier' % (
259
raise errors.BzrCommandError(gettext(
260
'bzr %s --revision takes exactly one revision identifier') % (
122
261
command_name,))
123
262
return revisions[0]
124
263
146
285
return rev_tree
147
286
148
287
149
# XXX: Bad function name; should possibly also be a class method of
150
# WorkingTree rather than a function.
151
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
152
apply_view=True):
153
"""Convert command-line paths to a WorkingTree and relative paths.
154
155
This is typically used for command-line processors that take one or
156
more filenames, and infer the workingtree that contains them.
157
158
The filenames given are not required to exist.
159
160
:param file_list: Filenames to convert.
161
162
:param default_branch: Fallback tree path to use if file_list is empty or
163
None.
164
165
:param apply_view: if True and a view is set, apply it or check that
166
specified files are within it
167
168
:return: workingtree, [relative_paths]
169
"""
170
if file_list is None or len(file_list) == 0:
171
tree = WorkingTree.open_containing(default_branch)[0]
172
if tree.supports_views() and apply_view:
173
view_files = tree.views.lookup_view()
174
if view_files:
175
file_list = view_files
176
view_str = views.view_display_str(view_files)
177
note("Ignoring files outside view. View is %s" % view_str)
178
return tree, file_list
179
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
180
return tree, safe_relpath_files(tree, file_list, canonicalize,
181
apply_view=apply_view)
182
183
184
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
185
"""Convert file_list into a list of relpaths in tree.
186
187
:param tree: A tree to operate on.
188
:param file_list: A list of user provided paths or None.
189
:param apply_view: if True and a view is set, apply it or check that
190
specified files are within it
191
:return: A list of relative paths.
192
:raises errors.PathNotChild: When a provided path is in a different tree
193
than tree.
194
"""
195
if file_list is None:
196
return None
197
if tree.supports_views() and apply_view:
198
view_files = tree.views.lookup_view()
199
else:
200
view_files = []
201
new_list = []
202
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
203
# doesn't - fix that up here before we enter the loop.
204
if canonicalize:
205
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
206
else:
207
fixer = tree.relpath
208
for filename in file_list:
209
try:
210
relpath = fixer(osutils.dereference_path(filename))
211
if view_files and not osutils.is_inside_any(view_files, relpath):
212
raise errors.FileOutsideView(filename, view_files)
213
new_list.append(relpath)
214
except errors.PathNotChild:
215
raise errors.FileInWrongBranch(tree.branch, filename)
216
return new_list
217
218
219
288
def _get_view_info_for_change_reporter(tree):
220
289
"""Get the view information from a tree for change reporting."""
221
290
view_info = None
228
297
return view_info
229
298
230
299
300
def _open_directory_or_containing_tree_or_branch(filename, directory):
301
"""Open the tree or branch containing the specified file, unless
302
the --directory option is used to specify a different branch."""
303
if directory is not None:
304
return (None, Branch.open(directory), filename)
305
return controldir.ControlDir.open_containing_tree_or_branch(filename)
306
307
231
308
# TODO: Make sure no commands unconditionally use the working directory as a
232
309
# branch. If a filename argument is used, the first of them should be used to
233
310
# specify the branch. (Perhaps this can be factored out into some kind of
235
312
# opens the branch?)
236
313
237
314
class cmd_status(Command):
238
"""Display status summary.
315
__doc__ = """Display status summary.
239
316
240
317
This reports on versioned and unknown files, reporting them
241
318
grouped by state. Possible states are:
261
338
unknown
262
339
Not versioned and not matching an ignore pattern.
263
340
264
Additionally for directories, symlinks and files with an executable
265
bit, Bazaar indicates their type using a trailing character: '/', '@'
266
or '*' respectively.
341
Additionally for directories, symlinks and files with a changed
342
executable bit, Bazaar indicates their type using a trailing
343
character: '/', '@' or '*' respectively. These decorations can be
344
disabled using the '--no-classify' option.
267
345
268
346
To see ignored files use 'bzr ignored'. For details on the
269
347
changes to file texts, use 'bzr diff'.
282
360
To skip the display of pending merge information altogether, use
283
361
the no-pending option or specify a file/directory.
284
362
285
If a revision argument is given, the status is calculated against
286
that revision, or between two revisions if two are provided.
363
To compare the working directory to a specific revision, pass a
364
single revision to the revision argument.
365
366
To see which files have changed in a specific revision, or between
367
two revisions, pass a revision range to the revision argument.
368
This will produce the same results as calling 'bzr diff --summarize'.
287
369
"""
288
370
289
# TODO: --no-recurse, --recurse options
371
# TODO: --no-recurse/-N, --recurse options
290
372
291
373
takes_args = ['file*']
292
374
takes_options = ['show-ids', 'revision', 'change', 'verbose',
296
378
short_name='V'),
297
379
Option('no-pending', help='Don\'t show pending merges.',
298
380
),
381
Option('no-classify',
382
help='Do not mark object type using indicator.',
383
),
299
384
]
300
385
aliases = ['st', 'stat']
301
386
304
389
305
390
@display_command
306
391
def run(self, show_ids=False, file_list=None, revision=None, short=False,
307
versioned=False, no_pending=False, verbose=False):
392
versioned=False, no_pending=False, verbose=False,
393
no_classify=False):
308
394
from bzrlib.status import show_tree_status
309
395
310
396
if revision and len(revision) > 2:
311
raise errors.BzrCommandError('bzr status --revision takes exactly'
312
' one or two revision specifiers')
397
raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
398
' one or two revision specifiers'))
313
399
314
tree, relfile_list = tree_files(file_list)
400
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
315
401
# Avoid asking for specific files when that is not needed.
316
402
if relfile_list == ['']:
317
403
relfile_list = None
324
410
show_tree_status(tree, show_ids=show_ids,
325
411
specific_files=relfile_list, revision=revision,
326
412
to_file=self.outf, short=short, versioned=versioned,
327
show_pending=(not no_pending), verbose=verbose)
413
show_pending=(not no_pending), verbose=verbose,
414
classify=not no_classify)
328
415
329
416
330
417
class cmd_cat_revision(Command):
331
"""Write out metadata for a revision.
418
__doc__ = """Write out metadata for a revision.
332
419
333
420
The revision to print can either be specified by a specific
334
421
revision identifier, or you can use --revision.
336
423
337
424
hidden = True
338
425
takes_args = ['revision_id?']
339
takes_options = ['revision']
426
takes_options = ['directory', 'revision']
340
427
# cat-revision is more for frontends so should be exact
341
428
encoding = 'strict'
342
429
349
436
self.outf.write(revtext.decode('utf-8'))
350
437
351
438
@display_command
352
def run(self, revision_id=None, revision=None):
439
def run(self, revision_id=None, revision=None, directory=u'.'):
353
440
if revision_id is not None and revision is not None:
354
raise errors.BzrCommandError('You can only supply one of'
355
' revision_id or --revision')
441
raise errors.BzrCommandError(gettext('You can only supply one of'
442
' revision_id or --revision'))
356
443
if revision_id is None and revision is None:
357
raise errors.BzrCommandError('You must supply either'
358
' --revision or a revision_id')
359
b = WorkingTree.open_containing(u'.')[0].branch
444
raise errors.BzrCommandError(gettext('You must supply either'
445
' --revision or a revision_id'))
446
447
b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]
360
448
361
449
revisions = b.repository.revisions
362
450
if revisions is None:
363
raise errors.BzrCommandError('Repository %r does not support '
364
'access to raw revision texts')
451
raise errors.BzrCommandError(gettext('Repository %r does not support '
452
'access to raw revision texts'))
365
453
366
454
b.repository.lock_read()
367
455
try:
371
459
try:
372
460
self.print_revision(revisions, revision_id)
373
461
except errors.NoSuchRevision:
374
msg = "The repository %s contains no revision %s." % (
462
msg = gettext("The repository {0} contains no revision {1}.").format(
375
463
b.repository.base, revision_id)
376
464
raise errors.BzrCommandError(msg)
377
465
elif revision is not None:
378
466
for rev in revision:
379
467
if rev is None:
380
468
raise errors.BzrCommandError(
381
'You cannot specify a NULL revision.')
469
gettext('You cannot specify a NULL revision.'))
382
470
rev_id = rev.as_revision_id(b)
383
471
self.print_revision(revisions, rev_id)
384
472
finally:
386
474
387
475
388
476
class cmd_dump_btree(Command):
389
"""Dump the contents of a btree index file to stdout.
477
__doc__ = """Dump the contents of a btree index file to stdout.
390
478
391
479
PATH is a btree index file, it can be any URL. This includes things like
392
480
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
440
528
self.outf.write(page_bytes[:header_end])
441
529
page_bytes = data
442
530
self.outf.write('\nPage %d\n' % (page_idx,))
443
decomp_bytes = zlib.decompress(page_bytes)
444
self.outf.write(decomp_bytes)
445
self.outf.write('\n')
531
if len(page_bytes) == 0:
532
self.outf.write('(empty)\n');
533
else:
534
decomp_bytes = zlib.decompress(page_bytes)
535
self.outf.write(decomp_bytes)
536
self.outf.write('\n')
446
537
447
538
def _dump_entries(self, trans, basename):
448
539
try:
456
547
for node in bt.iter_all_entries():
457
548
# Node is made up of:
458
549
# (index, key, value, [references])
459
refs_as_tuples = static_tuple.as_tuples(node[3])
550
try:
551
refs = node[3]
552
except IndexError:
553
refs_as_tuples = None
554
else:
555
refs_as_tuples = static_tuple.as_tuples(refs)
460
556
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
461
557
self.outf.write('%s\n' % (as_tuple,))
462
558
463
559
464
560
class cmd_remove_tree(Command):
465
"""Remove the working tree from a given branch/checkout.
561
__doc__ = """Remove the working tree from a given branch/checkout.
466
562
467
563
Since a lightweight checkout is little more than a working tree
468
564
this will refuse to run against one.
474
570
takes_options = [
475
571
Option('force',
476
572
help='Remove the working tree even if it has '
477
'uncommitted changes.'),
573
'uncommitted or shelved changes.'),
478
574
]
479
575
480
576
def run(self, location_list, force=False):
482
578
location_list=['.']
483
579
484
580
for location in location_list:
485
d = bzrdir.BzrDir.open(location)
486
581
d = controldir.ControlDir.open(location)
582
487
583
try:
488
584
working = d.open_workingtree()
489
585
except errors.NoWorkingTree:
490
raise errors.BzrCommandError("No working tree to remove")
586
raise errors.BzrCommandError(gettext("No working tree to remove"))
491
587
except errors.NotLocalUrl:
492
raise errors.BzrCommandError("You cannot remove the working tree"
493
" of a remote path")
588
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
589
" of a remote path"))
494
590
if not force:
495
591
if (working.has_changes()):
496
592
raise errors.UncommittedChanges(working)
593
if working.get_shelf_manager().last_shelf() is not None:
594
raise errors.ShelvedChanges(working)
497
595
498
working_path = working.bzrdir.root_transport.base
499
branch_path = working.branch.bzrdir.root_transport.base
500
if working_path != branch_path:
501
raise errors.BzrCommandError("You cannot remove the working tree"
502
" from a lightweight checkout")
596
if working.user_url != working.branch.user_url:
597
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
598
" from a lightweight checkout"))
503
599
504
600
d.destroy_workingtree()
505
601
506
602
603
class cmd_repair_workingtree(Command):
604
__doc__ = """Reset the working tree state file.
605
606
This is not meant to be used normally, but more as a way to recover from
607
filesystem corruption, etc. This rebuilds the working inventory back to a
608
'known good' state. Any new modifications (adding a file, renaming, etc)
609
will be lost, though modified files will still be detected as such.
610
611
Most users will want something more like "bzr revert" or "bzr update"
612
unless the state file has become corrupted.
613
614
By default this attempts to recover the current state by looking at the
615
headers of the state file. If the state file is too corrupted to even do
616
that, you can supply --revision to force the state of the tree.
617
"""
618
619
takes_options = ['revision', 'directory',
620
Option('force',
621
help='Reset the tree even if it doesn\'t appear to be'
622
' corrupted.'),
623
]
624
hidden = True
625
626
def run(self, revision=None, directory='.', force=False):
627
tree, _ = WorkingTree.open_containing(directory)
628
self.add_cleanup(tree.lock_tree_write().unlock)
629
if not force:
630
try:
631
tree.check_state()
632
except errors.BzrError:
633
pass # There seems to be a real error here, so we'll reset
634
else:
635
# Refuse
636
raise errors.BzrCommandError(gettext(
637
'The tree does not appear to be corrupt. You probably'
638
' want "bzr revert" instead. Use "--force" if you are'
639
' sure you want to reset the working tree.'))
640
if revision is None:
641
revision_ids = None
642
else:
643
revision_ids = [r.as_revision_id(tree.branch) for r in revision]
644
try:
645
tree.reset_state(revision_ids)
646
except errors.BzrError, e:
647
if revision_ids is None:
648
extra = (gettext(', the header appears corrupt, try passing -r -1'
649
' to set the state to the last commit'))
650
else:
651
extra = ''
652
raise errors.BzrCommandError(gettext('failed to reset the tree state{0}').format(extra))
653
654
507
655
class cmd_revno(Command):
508
"""Show current revision number.
656
__doc__ = """Show current revision number.
509
657
510
658
This is equal to the number of revisions on this branch.
511
659
"""
513
661
_see_also = ['info']
514
662
takes_args = ['location?']
515
663
takes_options = [
516
Option('tree', help='Show revno of working tree'),
664
Option('tree', help='Show revno of working tree.'),
665
'revision',
517
666
]
518
667
519
668
@display_command
520
def run(self, tree=False, location=u'.'):
669
def run(self, tree=False, location=u'.', revision=None):
670
if revision is not None and tree:
671
raise errors.BzrCommandError(gettext("--tree and --revision can "
672
"not be used together"))
673
521
674
if tree:
522
675
try:
523
676
wt = WorkingTree.open_containing(location)[0]
524
wt.lock_read()
677
self.add_cleanup(wt.lock_read().unlock)
525
678
except (errors.NoWorkingTree, errors.NotLocalUrl):
526
679
raise errors.NoWorkingTree(location)
527
self.add_cleanup(wt.unlock)
680
b = wt.branch
528
681
revid = wt.last_revision()
529
try:
530
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
531
except errors.NoSuchRevision:
532
revno_t = ('???',)
533
revno = ".".join(str(n) for n in revno_t)
534
682
else:
535
683
b = Branch.open_containing(location)[0]
536
b.lock_read()
537
self.add_cleanup(b.unlock)
538
revno = b.revno()
684
self.add_cleanup(b.lock_read().unlock)
685
if revision:
686
if len(revision) != 1:
687
raise errors.BzrCommandError(gettext(
688
"Revision numbers only make sense for single "
689
"revisions, not ranges"))
690
revid = revision[0].as_revision_id(b)
691
else:
692
revid = b.last_revision()
693
try:
694
revno_t = b.revision_id_to_dotted_revno(revid)
695
except errors.NoSuchRevision:
696
revno_t = ('???',)
697
revno = ".".join(str(n) for n in revno_t)
539
698
self.cleanup_now()
540
self.outf.write(str(revno) + '\n')
699
self.outf.write(revno + '\n')
541
700
542
701
543
702
class cmd_revision_info(Command):
544
"""Show revision number and revision id for a given revision identifier.
703
__doc__ = """Show revision number and revision id for a given revision identifier.
545
704
"""
546
705
hidden = True
547
706
takes_args = ['revision_info*']
548
707
takes_options = [
549
708
'revision',
550
Option('directory',
709
custom_help('directory',
551
710
help='Branch to examine, '
552
'rather than the one containing the working directory.',
553
short_name='d',
554
type=unicode,
555
),
556
Option('tree', help='Show revno of working tree'),
711
'rather than the one containing the working directory.'),
712
Option('tree', help='Show revno of working tree.'),
557
713
]
558
714
559
715
@display_command
563
719
try:
564
720
wt = WorkingTree.open_containing(directory)[0]
565
721
b = wt.branch
566
wt.lock_read()
567
self.add_cleanup(wt.unlock)
722
self.add_cleanup(wt.lock_read().unlock)
568
723
except (errors.NoWorkingTree, errors.NotLocalUrl):
569
724
wt = None
570
725
b = Branch.open_containing(directory)[0]
571
b.lock_read()
572
self.add_cleanup(b.unlock)
726
self.add_cleanup(b.lock_read().unlock)
573
727
revision_ids = []
574
728
if revision is not None:
575
729
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
603
757
604
758
605
759
class cmd_add(Command):
606
"""Add specified files or directories.
760
__doc__ = """Add specified files or directories.
607
761
608
762
In non-recursive mode, all the named items are added, regardless
609
763
of whether they were previously ignored. A warning is given if
617
771
are added. This search proceeds recursively into versioned
618
772
directories. If no names are given '.' is assumed.
619
773
774
A warning will be printed when nested trees are encountered,
775
unless they are explicitly ignored.
776
620
777
Therefore simply saying 'bzr add' will version all files that
621
778
are currently unknown.
622
779
638
795
639
796
Any files matching patterns in the ignore list will not be added
640
797
unless they are explicitly mentioned.
798
799
In recursive mode, files larger than the configuration option
800
add.maximum_file_size will be skipped. Named items are never skipped due
801
to file size.
641
802
"""
642
803
takes_args = ['file*']
643
804
takes_options = [
644
805
Option('no-recurse',
645
help="Don't recursively add the contents of directories."),
806
help="Don't recursively add the contents of directories.",
807
short_name='N'),
646
808
Option('dry-run',
647
809
help="Show what would be done, but don't actually do anything."),
648
810
'verbose',
670
832
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
671
833
to_file=self.outf, should_print=(not is_quiet()))
672
834
else:
673
action = bzrlib.add.AddAction(to_file=self.outf,
835
action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
674
836
should_print=(not is_quiet()))
675
837
676
838
if base_tree:
677
base_tree.lock_read()
678
self.add_cleanup(base_tree.unlock)
839
self.add_cleanup(base_tree.lock_read().unlock)
679
840
tree, file_list = tree_files_for_add(file_list)
680
841
added, ignored = tree.smart_add(file_list, not
681
842
no_recurse, action=action, save=not dry_run)
684
845
if verbose:
685
846
for glob in sorted(ignored.keys()):
686
847
for path in ignored[glob]:
687
self.outf.write("ignored %s matching \"%s\"\n"
688
% (path, glob))
848
self.outf.write(
849
gettext("ignored {0} matching \"{1}\"\n").format(
850
path, glob))
689
851
690
852
691
853
class cmd_mkdir(Command):
692
"""Create a new versioned directory.
854
__doc__ = """Create a new versioned directory.
693
855
694
856
This is equivalent to creating the directory and then adding it.
695
857
"""
696
858
697
859
takes_args = ['dir+']
860
takes_options = [
861
Option(
862
'parents',
863
help='No error if existing, make parent directories as needed.',
864
short_name='p'
865
)
866
]
698
867
encoding_type = 'replace'
699
868
700
def run(self, dir_list):
701
for d in dir_list:
702
os.mkdir(d)
703
wt, dd = WorkingTree.open_containing(d)
704
wt.add([dd])
705
self.outf.write('added %s\n' % d)
869
@classmethod
870
def add_file_with_parents(cls, wt, relpath):
871
if wt.path2id(relpath) is not None:
872
return
873
cls.add_file_with_parents(wt, osutils.dirname(relpath))
874
wt.add([relpath])
875
876
@classmethod
877
def add_file_single(cls, wt, relpath):
878
wt.add([relpath])
879
880
def run(self, dir_list, parents=False):
881
if parents:
882
add_file = self.add_file_with_parents
883
else:
884
add_file = self.add_file_single
885
for dir in dir_list:
886
wt, relpath = WorkingTree.open_containing(dir)
887
if parents:
888
try:
889
os.makedirs(dir)
890
except OSError, e:
891
if e.errno != errno.EEXIST:
892
raise
893
else:
894
os.mkdir(dir)
895
add_file(wt, relpath)
896
if not is_quiet():
897
self.outf.write(gettext('added %s\n') % dir)
706
898
707
899
708
900
class cmd_relpath(Command):
709
"""Show path of a file relative to root"""
901
__doc__ = """Show path of a file relative to root"""
710
902
711
903
takes_args = ['filename']
712
904
hidden = True
721
913
722
914
723
915
class cmd_inventory(Command):
724
"""Show inventory of the current working copy or a revision.
916
__doc__ = """Show inventory of the current working copy or a revision.
725
917
726
918
It is possible to limit the output to a particular entry
727
919
type using the --kind option. For example: --kind file.
744
936
@display_command
745
937
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
746
938
if kind and kind not in ['file', 'directory', 'symlink']:
747
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
939
raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
748
940
749
941
revision = _get_one_revision('inventory', revision)
750
work_tree, file_list = tree_files(file_list)
751
work_tree.lock_read()
752
self.add_cleanup(work_tree.unlock)
942
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
943
self.add_cleanup(work_tree.lock_read().unlock)
753
944
if revision is not None:
754
945
tree = revision.as_tree(work_tree.branch)
755
946
756
947
extra_trees = [work_tree]
757
tree.lock_read()
758
self.add_cleanup(tree.unlock)
948
self.add_cleanup(tree.lock_read().unlock)
759
949
else:
760
950
tree = work_tree
761
951
extra_trees = []
762
952
953
self.add_cleanup(tree.lock_read().unlock)
763
954
if file_list is not None:
764
955
file_ids = tree.paths2ids(file_list, trees=extra_trees,
765
956
require_versioned=True)
766
957
# find_ids_across_trees may include some paths that don't
767
958
# exist in 'tree'.
768
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
769
for file_id in file_ids if file_id in tree)
959
entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
770
960
else:
771
entries = tree.inventory.entries()
961
entries = tree.iter_entries_by_dir()
772
962
773
self.cleanup_now()
774
for path, entry in entries:
963
for path, entry in sorted(entries):
775
964
if kind and kind != entry.kind:
776
965
continue
966
if path == "":
967
continue
777
968
if show_ids:
778
969
self.outf.write('%-50s %s\n' % (path, entry.file_id))
779
970
else:
782
973
783
974
784
975
class cmd_mv(Command):
785
"""Move or rename a file.
976
__doc__ = """Move or rename a file.
786
977
787
978
:Usage:
788
979
bzr mv OLDNAME NEWNAME
815
1006
if auto:
816
1007
return self.run_auto(names_list, after, dry_run)
817
1008
elif dry_run:
818
raise errors.BzrCommandError('--dry-run requires --auto.')
1009
raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
819
1010
if names_list is None:
820
1011
names_list = []
821
1012
if len(names_list) < 2:
822
raise errors.BzrCommandError("missing file argument")
823
tree, rel_names = tree_files(names_list, canonicalize=False)
824
tree.lock_tree_write()
825
self.add_cleanup(tree.unlock)
1013
raise errors.BzrCommandError(gettext("missing file argument"))
1014
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
1015
for file_name in rel_names[0:-1]:
1016
if file_name == '':
1017
raise errors.BzrCommandError(gettext("can not move root of branch"))
1018
self.add_cleanup(tree.lock_tree_write().unlock)
826
1019
self._run(tree, names_list, rel_names, after)
827
1020
828
1021
def run_auto(self, names_list, after, dry_run):
829
1022
if names_list is not None and len(names_list) > 1:
830
raise errors.BzrCommandError('Only one path may be specified to'
831
' --auto.')
1023
raise errors.BzrCommandError(gettext('Only one path may be specified to'
1024
' --auto.'))
832
1025
if after:
833
raise errors.BzrCommandError('--after cannot be specified with'
834
' --auto.')
835
work_tree, file_list = tree_files(names_list, default_branch='.')
836
work_tree.lock_tree_write()
837
self.add_cleanup(work_tree.unlock)
1026
raise errors.BzrCommandError(gettext('--after cannot be specified with'
1027
' --auto.'))
1028
work_tree, file_list = WorkingTree.open_containing_paths(
1029
names_list, default_directory='.')
1030
self.add_cleanup(work_tree.lock_tree_write().unlock)
838
1031
rename_map.RenameMap.guess_renames(work_tree, dry_run)
839
1032
840
1033
def _run(self, tree, names_list, rel_names, after):
849
1042
and rel_names[0].lower() == rel_names[1].lower()):
850
1043
into_existing = False
851
1044
else:
852
inv = tree.inventory
853
1045
# 'fix' the case of a potential 'from'
854
1046
from_id = tree.path2id(
855
1047
tree.get_canonical_inventory_path(rel_names[0]))
856
1048
if (not osutils.lexists(names_list[0]) and
857
from_id and inv.get_file_kind(from_id) == "directory"):
1049
from_id and tree.stored_kind(from_id) == "directory"):
858
1050
into_existing = False
859
1051
# move/rename
860
1052
if into_existing:
867
1059
self.outf.write("%s => %s\n" % (src, dest))
868
1060
else:
869
1061
if len(names_list) != 2:
870
raise errors.BzrCommandError('to mv multiple files the'
1062
raise errors.BzrCommandError(gettext('to mv multiple files the'
871
1063
' destination must be a versioned'
872
' directory')
1064
' directory'))
873
1065
874
1066
# for cicp file-systems: the src references an existing inventory
875
1067
# item:
919
1111
920
1112
921
1113
class cmd_pull(Command):
922
"""Turn this branch into a mirror of another branch.
1114
__doc__ = """Turn this branch into a mirror of another branch.
923
1115
924
1116
By default, this command only works on branches that have not diverged.
925
1117
Branches are considered diverged if the destination branch's most recent
934
1126
match the remote one, use pull --overwrite. This will work even if the two
935
1127
branches have diverged.
936
1128
937
If there is no default location set, the first pull will set it. After
938
that, you can omit the location to use the default. To change the
939
default, use --remember. The value will only be saved if the remote
940
location can be accessed.
1129
If there is no default location set, the first pull will set it (use
1130
--no-remember to avoid setting it). After that, you can omit the
1131
location to use the default. To change the default, use --remember. The
1132
value will only be saved if the remote location can be accessed.
1133
1134
The --verbose option will display the revisions pulled using the log_format
1135
configuration option. You can use a different format by overriding it with
1136
-Olog_format=<other_format>.
941
1137
942
1138
Note: The location can be specified either in the form of a branch,
943
1139
or in the form of a path to a file containing a merge directive generated
948
1144
takes_options = ['remember', 'overwrite', 'revision',
949
1145
custom_help('verbose',
950
1146
help='Show logs of pulled revisions.'),
951
Option('directory',
1147
custom_help('directory',
952
1148
help='Branch to pull into, '
953
'rather than the one containing the working directory.',
954
short_name='d',
955
type=unicode,
956
),
1149
'rather than the one containing the working directory.'),
957
1150
Option('local',
958
1151
help="Perform a local pull in a bound "
959
1152
"branch. Local pulls are not applied to "
960
1153
"the master branch."
961
1154
),
1155
Option('show-base',
1156
help="Show base revision text in conflicts."),
1157
Option('overwrite-tags',
1158
help="Overwrite tags only."),
962
1159
]
963
1160
takes_args = ['location?']
964
1161
encoding_type = 'replace'
965
1162
966
def run(self, location=None, remember=False, overwrite=False,
1163
def run(self, location=None, remember=None, overwrite=False,
967
1164
revision=None, verbose=False,
968
directory=None, local=False):
1165
directory=None, local=False,
1166
show_base=False, overwrite_tags=False):
1167
1168
if overwrite:
1169
overwrite = ["history", "tags"]
1170
elif overwrite_tags:
1171
overwrite = ["tags"]
1172
else:
1173
overwrite = []
969
1174
# FIXME: too much stuff is in the command class
970
1175
revision_id = None
971
1176
mergeable = None
974
1179
try:
975
1180
tree_to = WorkingTree.open_containing(directory)[0]
976
1181
branch_to = tree_to.branch
1182
self.add_cleanup(tree_to.lock_write().unlock)
977
1183
except errors.NoWorkingTree:
978
1184
tree_to = None
979
1185
branch_to = Branch.open_containing(directory)[0]
980
1186
self.add_cleanup(branch_to.lock_write().unlock)
1187
if show_base:
1188
warning(gettext("No working tree, ignoring --show-base"))
1189
981
1190
if local and not branch_to.get_bound_location():
982
1191
raise errors.LocalRequiresBoundBranch()
983
1192
992
1201
stored_loc = branch_to.get_parent()
993
1202
if location is None:
994
1203
if stored_loc is None:
995
raise errors.BzrCommandError("No pull location known or"
996
" specified.")
1204
raise errors.BzrCommandError(gettext("No pull location known or"
1205
" specified."))
997
1206
else:
998
1207
display_url = urlutils.unescape_for_display(stored_loc,
999
1208
self.outf.encoding)
1000
1209
if not is_quiet():
1001
self.outf.write("Using saved parent location: %s\n" % display_url)
1210
self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
1002
1211
location = stored_loc
1003
1212
1004
1213
revision = _get_one_revision('pull', revision)
1005
1214
if mergeable is not None:
1006
1215
if revision is not None:
1007
raise errors.BzrCommandError(
1008
'Cannot use -r with merge directives or bundles')
1216
raise errors.BzrCommandError(gettext(
1217
'Cannot use -r with merge directives or bundles'))
1009
1218
mergeable.install_revisions(branch_to.repository)
1010
1219
base_revision_id, revision_id, verified = \
1011
1220
mergeable.get_merge_request(branch_to.repository)
1013
1222
else:
1014
1223
branch_from = Branch.open(location,
1015
1224
possible_transports=possible_transports)
1016
1017
if branch_to.get_parent() is None or remember:
1225
self.add_cleanup(branch_from.lock_read().unlock)
1226
# Remembers if asked explicitly or no previous location is set
1227
if (remember
1228
or (remember is None and branch_to.get_parent() is None)):
1229
# FIXME: This shouldn't be done before the pull
1230
# succeeds... -- vila 2012-01-02
1018
1231
branch_to.set_parent(branch_from.base)
1019
1232
1020
if branch_from is not branch_to:
1021
branch_from.lock_read()
1022
self.add_cleanup(branch_from.unlock)
1023
1233
if revision is not None:
1024
1234
revision_id = revision.as_revision_id(branch_from)
1025
1235
1026
branch_to.lock_write()
1027
self.add_cleanup(branch_to.unlock)
1028
1236
if tree_to is not None:
1029
1237
view_info = _get_view_info_for_change_reporter(tree_to)
1030
1238
change_reporter = delta._ChangeReporter(
1032
1240
view_info=view_info)
1033
1241
result = tree_to.pull(
1034
1242
branch_from, overwrite, revision_id, change_reporter,
1035
possible_transports=possible_transports, local=local)
1243
local=local, show_base=show_base)
1036
1244
else:
1037
1245
result = branch_to.pull(
1038
1246
branch_from, overwrite, revision_id, local=local)
1042
1250
log.show_branch_change(
1043
1251
branch_to, self.outf, result.old_revno,
1044
1252
result.old_revid)
1253
if getattr(result, 'tag_conflicts', None):
1254
return 1
1255
else:
1256
return 0
1045
1257
1046
1258
1047
1259
class cmd_push(Command):
1048
"""Update a mirror of this branch.
1260
__doc__ = """Update a mirror of this branch.
1049
1261
1050
1262
The target branch will not have its working tree populated because this
1051
1263
is both expensive, and is not supported on remote file systems.
1064
1276
do a merge (see bzr help merge) from the other branch, and commit that.
1065
1277
After that you will be able to do a push without '--overwrite'.
1066
1278
1067
If there is no default push location set, the first push will set it.
1068
After that, you can omit the location to use the default. To change the
1069
default, use --remember. The value will only be saved if the remote
1070
location can be accessed.
1279
If there is no default push location set, the first push will set it (use
1280
--no-remember to avoid setting it). After that, you can omit the
1281
location to use the default. To change the default, use --remember. The
1282
value will only be saved if the remote location can be accessed.
1283
1284
The --verbose option will display the revisions pushed using the log_format
1285
configuration option. You can use a different format by overriding it with
1286
-Olog_format=<other_format>.
1071
1287
"""
1072
1288
1073
1289
_see_also = ['pull', 'update', 'working-trees']
1075
1291
Option('create-prefix',
1076
1292
help='Create the path leading up to the branch '
1077
1293
'if it does not already exist.'),
1078
Option('directory',
1294
custom_help('directory',
1079
1295
help='Branch to push from, '
1080
'rather than the one containing the working directory.',
1081
short_name='d',
1082
type=unicode,
1083
),
1296
'rather than the one containing the working directory.'),
1084
1297
Option('use-existing-dir',
1085
1298
help='By default push will fail if the target'
1086
1299
' directory exists, but does not already'
1097
1310
Option('strict',
1098
1311
help='Refuse to push if there are uncommitted changes in'
1099
1312
' the working tree, --no-strict disables the check.'),
1313
Option('no-tree',
1314
help="Don't populate the working tree, even for protocols"
1315
" that support it."),
1316
Option('overwrite-tags',
1317
help="Overwrite tags only."),
1100
1318
]
1101
1319
takes_args = ['location?']
1102
1320
encoding_type = 'replace'
1103
1321
1104
def run(self, location=None, remember=False, overwrite=False,
1322
def run(self, location=None, remember=None, overwrite=False,
1105
1323
create_prefix=False, verbose=False, revision=None,
1106
1324
use_existing_dir=False, directory=None, stacked_on=None,
1107
stacked=False, strict=None):
1325
stacked=False, strict=None, no_tree=False,
1326
overwrite_tags=False):
1108
1327
from bzrlib.push import _show_push_branch
1109
1328
1329
if overwrite:
1330
overwrite = ["history", "tags"]
1331
elif overwrite_tags:
1332
overwrite = ["tags"]
1333
else:
1334
overwrite = []
1335
1110
1336
if directory is None:
1111
1337
directory = '.'
1112
1338
# Get the source branch
1113
1339
(tree, br_from,
1114
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1115
if strict is None:
1116
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1117
if strict is None: strict = True # default value
1340
_unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1118
1341
# Get the tip's revision_id
1119
1342
revision = _get_one_revision('push', revision)
1120
1343
if revision is not None:
1121
1344
revision_id = revision.in_history(br_from).rev_id
1122
1345
else:
1123
1346
revision_id = None
1124
if strict and tree is not None and revision_id is None:
1125
if (tree.has_changes()):
1126
raise errors.UncommittedChanges(
1127
tree, more='Use --no-strict to force the push.')
1128
if tree.last_revision() != tree.branch.last_revision():
1129
# The tree has lost sync with its branch, there is little
1130
# chance that the user is aware of it but he can still force
1131
# the push with --no-strict
1132
raise errors.OutOfDateTree(
1133
tree, more='Use --no-strict to force the push.')
1134
1347
if tree is not None and revision_id is None:
1348
tree.check_changed_or_out_of_date(
1349
strict, 'push_strict',
1350
more_error='Use --no-strict to force the push.',
1351
more_warning='Uncommitted changes will not be pushed.')
1135
1352
# Get the stacked_on branch, if any
1136
1353
if stacked_on is not None:
1137
1354
stacked_on = urlutils.normalize_url(stacked_on)
1147
1364
# error by the feedback given to them. RBC 20080227.
1148
1365
stacked_on = parent_url
1149
1366
if not stacked_on:
1150
raise errors.BzrCommandError(
1151
"Could not determine branch to refer to.")
1367
raise errors.BzrCommandError(gettext(
1368
"Could not determine branch to refer to."))
1152
1369
1153
1370
# Get the destination location
1154
1371
if location is None:
1155
1372
stored_loc = br_from.get_push_location()
1156
1373
if stored_loc is None:
1157
raise errors.BzrCommandError(
1158
"No push location known or specified.")
1374
parent_loc = br_from.get_parent()
1375
if parent_loc:
1376
raise errors.BzrCommandError(gettext(
1377
"No push location known or specified. To push to the "
1378
"parent branch (at %s), use 'bzr push :parent'." %
1379
urlutils.unescape_for_display(parent_loc,
1380
self.outf.encoding)))
1381
else:
1382
raise errors.BzrCommandError(gettext(
1383
"No push location known or specified."))
1159
1384
else:
1160
1385
display_url = urlutils.unescape_for_display(stored_loc,
1161
1386
self.outf.encoding)
1162
self.outf.write("Using saved push location: %s\n" % display_url)
1387
note(gettext("Using saved push location: %s") % display_url)
1163
1388
location = stored_loc
1164
1389
1165
1390
_show_push_branch(br_from, revision_id, location, self.outf,
1166
1391
verbose=verbose, overwrite=overwrite, remember=remember,
1167
1392
stacked_on=stacked_on, create_prefix=create_prefix,
1168
use_existing_dir=use_existing_dir)
1393
use_existing_dir=use_existing_dir, no_tree=no_tree)
1169
1394
1170
1395
1171
1396
class cmd_branch(Command):
1172
"""Create a new branch that is a copy of an existing branch.
1397
__doc__ = """Create a new branch that is a copy of an existing branch.
1173
1398
1174
1399
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1175
1400
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1180
1405
1181
1406
To retrieve the branch as of a particular revision, supply the --revision
1182
1407
parameter, as in "branch foo/bar -r 5".
1408
1409
The synonyms 'clone' and 'get' for this command are deprecated.
1183
1410
"""
1184
1411
1185
1412
_see_also = ['checkout']
1186
1413
takes_args = ['from_location', 'to_location?']
1187
takes_options = ['revision', Option('hardlink',
1188
help='Hard-link working tree files where possible.'),
1414
takes_options = ['revision',
1415
Option('hardlink', help='Hard-link working tree files where possible.'),
1416
Option('files-from', type=str,
1417
help="Get file contents from this tree."),
1189
1418
Option('no-tree',
1190
1419
help="Create a branch without a working-tree."),
1191
1420
Option('switch',
1209
1438
1210
1439
def run(self, from_location, to_location=None, revision=None,
1211
1440
hardlink=False, stacked=False, standalone=False, no_tree=False,
1212
use_existing_dir=False, switch=False, bind=False):
1441
use_existing_dir=False, switch=False, bind=False,
1442
files_from=None):
1213
1443
from bzrlib import switch as _mod_switch
1214
1444
from bzrlib.tag import _merge_tags_if_possible
1215
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1445
if self.invoked_as in ['get', 'clone']:
1446
ui.ui_factory.show_user_warning(
1447
'deprecated_command',
1448
deprecated_name=self.invoked_as,
1449
recommended_name='branch',
1450
deprecated_in_version='2.4')
1451
accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(
1216
1452
from_location)
1453
if not (hardlink or files_from):
1454
# accelerator_tree is usually slower because you have to read N
1455
# files (no readahead, lots of seeks, etc), but allow the user to
1456
# explicitly request it
1457
accelerator_tree = None
1458
if files_from is not None and files_from != from_location:
1459
accelerator_tree = WorkingTree.open(files_from)
1217
1460
revision = _get_one_revision('branch', revision)
1218
br_from.lock_read()
1219
self.add_cleanup(br_from.unlock)
1461
self.add_cleanup(br_from.lock_read().unlock)
1220
1462
if revision is not None:
1221
1463
revision_id = revision.as_revision_id(br_from)
1222
1464
else:
1225
1467
# RBC 20060209
1226
1468
revision_id = br_from.last_revision()
1227
1469
if to_location is None:
1228
to_location = urlutils.derive_to_location(from_location)
1470
to_location = getattr(br_from, "name", None)
1471
if not to_location:
1472
to_location = urlutils.derive_to_location(from_location)
1229
1473
to_transport = transport.get_transport(to_location)
1230
1474
try:
1231
1475
to_transport.mkdir('.')
1232
1476
except errors.FileExists:
1233
if not use_existing_dir:
1234
raise errors.BzrCommandError('Target directory "%s" '
1235
'already exists.' % to_location)
1477
try:
1478
to_dir = controldir.ControlDir.open_from_transport(
1479
to_transport)
1480
except errors.NotBranchError:
1481
if not use_existing_dir:
1482
raise errors.BzrCommandError(gettext('Target directory "%s" '
1483
'already exists.') % to_location)
1484
else:
1485
to_dir = None
1236
1486
else:
1237
1487
try:
1238
bzrdir.BzrDir.open_from_transport(to_transport)
1488
to_dir.open_branch()
1239
1489
except errors.NotBranchError:
1240
1490
pass
1241
1491
else:
1242
1492
raise errors.AlreadyBranchError(to_location)
1243
1493
except errors.NoSuchFile:
1244
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1494
raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
1245
1495
% to_location)
1246
try:
1247
# preserve whatever source format we have.
1248
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1249
possible_transports=[to_transport],
1250
accelerator_tree=accelerator_tree,
1251
hardlink=hardlink, stacked=stacked,
1252
force_new_repo=standalone,
1253
create_tree_if_local=not no_tree,
1254
source_branch=br_from)
1255
branch = dir.open_branch()
1256
except errors.NoSuchRevision:
1257
to_transport.delete_tree('.')
1258
msg = "The branch %s has no revision %s." % (from_location,
1259
revision)
1260
raise errors.BzrCommandError(msg)
1496
else:
1497
to_dir = None
1498
if to_dir is None:
1499
try:
1500
# preserve whatever source format we have.
1501
to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1502
possible_transports=[to_transport],
1503
accelerator_tree=accelerator_tree,
1504
hardlink=hardlink, stacked=stacked,
1505
force_new_repo=standalone,
1506
create_tree_if_local=not no_tree,
1507
source_branch=br_from)
1508
branch = to_dir.open_branch(
1509
possible_transports=[
1510
br_from.bzrdir.root_transport, to_transport])
1511
except errors.NoSuchRevision:
1512
to_transport.delete_tree('.')
1513
msg = gettext("The branch {0} has no revision {1}.").format(
1514
from_location, revision)
1515
raise errors.BzrCommandError(msg)
1516
else:
1517
try:
1518
to_repo = to_dir.open_repository()
1519
except errors.NoRepositoryPresent:
1520
to_repo = to_dir.create_repository()
1521
to_repo.fetch(br_from.repository, revision_id=revision_id)
1522
branch = br_from.sprout(to_dir, revision_id=revision_id)
1261
1523
_merge_tags_if_possible(br_from, branch)
1262
1524
# If the source branch is stacked, the new branch may
1263
1525
# be stacked whether we asked for that explicitly or not.
1264
1526
# We therefore need a try/except here and not just 'if stacked:'
1265
1527
try:
1266
note('Created new stacked branch referring to %s.' %
1528
note(gettext('Created new stacked branch referring to %s.') %
1267
1529
branch.get_stacked_on_url())
1268
1530
except (errors.NotStacked, errors.UnstackableBranchFormat,
1269
1531
errors.UnstackableRepositoryFormat), e:
1270
note('Branched %d revision(s).' % branch.revno())
1532
note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1271
1533
if bind:
1272
1534
# Bind to the parent
1273
1535
parent_branch = Branch.open(from_location)
1274
1536
branch.bind(parent_branch)
1275
note('New branch bound to %s' % from_location)
1537
note(gettext('New branch bound to %s') % from_location)
1276
1538
if switch:
1277
1539
# Switch to the new branch
1278
1540
wt, _ = WorkingTree.open_containing('.')
1279
1541
_mod_switch.switch(wt.bzrdir, branch)
1280
note('Switched to branch: %s',
1542
note(gettext('Switched to branch: %s'),
1281
1543
urlutils.unescape_for_display(branch.base, 'utf-8'))
1282
1544
1283
1545
1546
class cmd_branches(Command):
1547
__doc__ = """List the branches available at the current location.
1548
1549
This command will print the names of all the branches at the current
1550
location.
1551
"""
1552
1553
takes_args = ['location?']
1554
takes_options = [
1555
Option('recursive', short_name='R',
1556
help='Recursively scan for branches rather than '
1557
'just looking in the specified location.')]
1558
1559
def run(self, location=".", recursive=False):
1560
if recursive:
1561
t = transport.get_transport(location)
1562
if not t.listable():
1563
raise errors.BzrCommandError(
1564
"Can't scan this type of location.")
1565
for b in controldir.ControlDir.find_branches(t):
1566
self.outf.write("%s\n" % urlutils.unescape_for_display(
1567
urlutils.relative_url(t.base, b.base),
1568
self.outf.encoding).rstrip("/"))
1569
else:
1570
dir = controldir.ControlDir.open_containing(location)[0]
1571
try:
1572
active_branch = dir.open_branch(name="")
1573
except errors.NotBranchError:
1574
active_branch = None
1575
names = {}
1576
for name, branch in iter_sibling_branches(dir):
1577
if name == "":
1578
continue
1579
active = (active_branch is not None and
1580
active_branch.base == branch.base)
1581
names[name] = active
1582
# Only mention the current branch explicitly if it's not
1583
# one of the colocated branches
1584
if not any(names.values()) and active_branch is not None:
1585
self.outf.write("* %s\n" % gettext("(default)"))
1586
for name in sorted(names.keys()):
1587
active = names[name]
1588
if active:
1589
prefix = "*"
1590
else:
1591
prefix = " "
1592
self.outf.write("%s %s\n" % (
1593
prefix, name.encode(self.outf.encoding)))
1594
1595
1284
1596
class cmd_checkout(Command):
1285
"""Create a new checkout of an existing branch.
1597
__doc__ = """Create a new checkout of an existing branch.
1286
1598
1287
1599
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1288
1600
the branch found in '.'. This is useful if you have removed the working tree
1302
1614
code.)
1303
1615
"""
1304
1616
1305
_see_also = ['checkouts', 'branch']
1617
_see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1306
1618
takes_args = ['branch_location?', 'to_location?']
1307
1619
takes_options = ['revision',
1308
1620
Option('lightweight',
1325
1637
if branch_location is None:
1326
1638
branch_location = osutils.getcwd()
1327
1639
to_location = branch_location
1328
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1640
accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1329
1641
branch_location)
1642
if not (hardlink or files_from):
1643
# accelerator_tree is usually slower because you have to read N
1644
# files (no readahead, lots of seeks, etc), but allow the user to
1645
# explicitly request it
1646
accelerator_tree = None
1330
1647
revision = _get_one_revision('checkout', revision)
1331
if files_from is not None:
1648
if files_from is not None and files_from != branch_location:
1332
1649
accelerator_tree = WorkingTree.open(files_from)
1333
1650
if revision is not None:
1334
1651
revision_id = revision.as_revision_id(source)
1351
1668
1352
1669
1353
1670
class cmd_renames(Command):
1354
"""Show list of renamed files.
1671
__doc__ = """Show list of renamed files.
1355
1672
"""
1356
1673
# TODO: Option to show renames between two historical versions.
1357
1674
1362
1679
@display_command
1363
1680
def run(self, dir=u'.'):
1364
1681
tree = WorkingTree.open_containing(dir)[0]
1365
tree.lock_read()
1366
self.add_cleanup(tree.unlock)
1367
new_inv = tree.inventory
1682
self.add_cleanup(tree.lock_read().unlock)
1368
1683
old_tree = tree.basis_tree()
1369
old_tree.lock_read()
1370
self.add_cleanup(old_tree.unlock)
1371
old_inv = old_tree.inventory
1684
self.add_cleanup(old_tree.lock_read().unlock)
1372
1685
renames = []
1373
1686
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1374
1687
for f, paths, c, v, p, n, k, e in iterator:
1383
1696
1384
1697
1385
1698
class cmd_update(Command):
1386
"""Update a tree to have the latest code committed to its branch.
1387
1388
This will perform a merge into the working tree, and may generate
1389
conflicts. If you have any local changes, you will still
1390
need to commit them after the update for the update to be complete.
1391
1392
If you want to discard your local changes, you can just do a
1393
'bzr revert' instead of 'bzr commit' after the update.
1394
1395
If the tree's branch is bound to a master branch, it will also update
1699
__doc__ = """Update a working tree to a new revision.
1700
1701
This will perform a merge of the destination revision (the tip of the
1702
branch, or the specified revision) into the working tree, and then make
1703
that revision the basis revision for the working tree.
1704
1705
You can use this to visit an older revision, or to update a working tree
1706
that is out of date from its branch.
1707
1708
If there are any uncommitted changes in the tree, they will be carried
1709
across and remain as uncommitted changes after the update. To discard
1710
these changes, use 'bzr revert'. The uncommitted changes may conflict
1711
with the changes brought in by the change in basis revision.
1712
1713
If the tree's branch is bound to a master branch, bzr will also update
1396
1714
the branch from the master.
1715
1716
You cannot update just a single file or directory, because each Bazaar
1717
working tree has just a single basis revision. If you want to restore a
1718
file that has been removed locally, use 'bzr revert' instead of 'bzr
1719
update'. If you want to restore a file to its state in a previous
1720
revision, use 'bzr revert' with a '-r' option, or use 'bzr cat' to write
1721
out the old content of that file to a new location.
1722
1723
The 'dir' argument, if given, must be the location of the root of a
1724
working tree to update. By default, the working tree that contains the
1725
current working directory is used.
1397
1726
"""
1398
1727
1399
1728
_see_also = ['pull', 'working-trees', 'status-flags']
1400
1729
takes_args = ['dir?']
1401
takes_options = ['revision']
1730
takes_options = ['revision',
1731
Option('show-base',
1732
help="Show base revision text in conflicts."),
1733
]
1402
1734
aliases = ['up']
1403
1735
1404
def run(self, dir='.', revision=None):
1736
def run(self, dir=None, revision=None, show_base=None):
1405
1737
if revision is not None and len(revision) != 1:
1406
raise errors.BzrCommandError(
1407
"bzr update --revision takes exactly one revision")
1408
tree = WorkingTree.open_containing(dir)[0]
1738
raise errors.BzrCommandError(gettext(
1739
"bzr update --revision takes exactly one revision"))
1740
if dir is None:
1741
tree = WorkingTree.open_containing('.')[0]
1742
else:
1743
tree, relpath = WorkingTree.open_containing(dir)
1744
if relpath:
1745
# See bug 557886.
1746
raise errors.BzrCommandError(gettext(
1747
"bzr update can only update a whole tree, "
1748
"not a file or subdirectory"))
1409
1749
branch = tree.branch
1410
1750
possible_transports = []
1411
1751
master = branch.get_master_branch(
1412
1752
possible_transports=possible_transports)
1413
1753
if master is not None:
1414
tree.lock_write()
1415
1754
branch_location = master.base
1755
tree.lock_write()
1416
1756
else:
1757
branch_location = tree.branch.base
1417
1758
tree.lock_tree_write()
1418
branch_location = tree.branch.base
1419
1759
self.add_cleanup(tree.unlock)
1420
1760
# get rid of the final '/' and be ready for display
1421
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1422
self.outf.encoding)
1761
branch_location = urlutils.unescape_for_display(
1762
branch_location.rstrip('/'),
1763
self.outf.encoding)
1423
1764
existing_pending_merges = tree.get_parent_ids()[1:]
1424
1765
if master is None:
1425
1766
old_tip = None
1433
1774
else:
1434
1775
revision_id = branch.last_revision()
1435
1776
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1436
revno = branch.revision_id_to_revno(revision_id)
1437
note("Tree is up to date at revision %d of branch %s" %
1438
(revno, branch_location))
1777
revno = branch.revision_id_to_dotted_revno(revision_id)
1778
note(gettext("Tree is up to date at revision {0} of branch {1}"
1779
).format('.'.join(map(str, revno)), branch_location))
1439
1780
return 0
1440
1781
view_info = _get_view_info_for_change_reporter(tree)
1441
1782
change_reporter = delta._ChangeReporter(
1446
1787
change_reporter,
1447
1788
possible_transports=possible_transports,
1448
1789
revision=revision_id,
1449
old_tip=old_tip)
1790
old_tip=old_tip,
1791
show_base=show_base)
1450
1792
except errors.NoSuchRevision, e:
1451
raise errors.BzrCommandError(
1793
raise errors.BzrCommandError(gettext(
1452
1794
"branch has no revision %s\n"
1453
1795
"bzr update --revision only works"
1454
" for a revision in the branch history"
1796
" for a revision in the branch history")
1455
1797
% (e.revision))
1456
revno = tree.branch.revision_id_to_revno(
1798
revno = tree.branch.revision_id_to_dotted_revno(
1457
1799
_mod_revision.ensure_null(tree.last_revision()))
1458
note('Updated to revision %d of branch %s' %
1459
(revno, branch_location))
1460
if tree.get_parent_ids()[1:] != existing_pending_merges:
1461
note('Your local commits will now show as pending merges with '
1462
"'bzr status', and can be committed with 'bzr commit'.")
1800
note(gettext('Updated to revision {0} of branch {1}').format(
1801
'.'.join(map(str, revno)), branch_location))
1802
parent_ids = tree.get_parent_ids()
1803
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1804
note(gettext('Your local commits will now show as pending merges with '
1805
"'bzr status', and can be committed with 'bzr commit'."))
1463
1806
if conflicts != 0:
1464
1807
return 1
1465
1808
else:
1467
1810
1468
1811
1469
1812
class cmd_info(Command):
1470
"""Show information about a working tree, branch or repository.
1813
__doc__ = """Show information about a working tree, branch or repository.
1471
1814
1472
1815
This command will show all known locations and formats associated to the
1473
1816
tree, branch or repository.
1506
1849
else:
1507
1850
noise_level = 0
1508
1851
from bzrlib.info import show_bzrdir_info
1509
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1852
show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1510
1853
verbose=noise_level, outfile=self.outf)
1511
1854
1512
1855
1513
1856
class cmd_remove(Command):
1514
"""Remove files or directories.
1857
__doc__ = """Remove files or directories.
1515
1858
1516
This makes bzr stop tracking changes to the specified files. bzr will delete
1517
them if they can easily be recovered using revert. If no options or
1518
parameters are given bzr will scan for files that are being tracked by bzr
1519
but missing in your tree and stop tracking them for you.
1859
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1860
delete them if they can easily be recovered using revert otherwise they
1861
will be backed up (adding an extension of the form .~#~). If no options or
1862
parameters are given Bazaar will scan for files that are being tracked by
1863
Bazaar but missing in your tree and stop tracking them for you.
1520
1864
"""
1521
1865
takes_args = ['file*']
1522
1866
takes_options = ['verbose',
1524
1868
RegistryOption.from_kwargs('file-deletion-strategy',
1525
1869
'The file deletion mode to be used.',
1526
1870
title='Deletion Strategy', value_switches=True, enum_switch=False,
1527
safe='Only delete files if they can be'
1528
' safely recovered (default).',
1871
safe='Backup changed files (default).',
1529
1872
keep='Delete from bzr but leave the working copy.',
1530
force='Delete all the specified files, even if they can not be '
1531
'recovered and even if they are non-empty directories.')]
1873
no_backup='Don\'t backup changed files.'),
1874
]
1532
1875
aliases = ['rm', 'del']
1533
1876
encoding_type = 'replace'
1534
1877
1535
1878
def run(self, file_list, verbose=False, new=False,
1536
1879
file_deletion_strategy='safe'):
1537
tree, file_list = tree_files(file_list)
1880
1881
tree, file_list = WorkingTree.open_containing_paths(file_list)
1538
1882
1539
1883
if file_list is not None:
1540
1884
file_list = [f for f in file_list]
1541
1885
1542
tree.lock_write()
1543
self.add_cleanup(tree.unlock)
1886
self.add_cleanup(tree.lock_write().unlock)
1544
1887
# Heuristics should probably all move into tree.remove_smart or
1545
1888
# some such?
1546
1889
if new:
1548
1891
specific_files=file_list).added
1549
1892
file_list = sorted([f[0] for f in added], reverse=True)
1550
1893
if len(file_list) == 0:
1551
raise errors.BzrCommandError('No matching files.')
1894
raise errors.BzrCommandError(gettext('No matching files.'))
1552
1895
elif file_list is None:
1553
1896
# missing files show up in iter_changes(basis) as
1554
1897
# versioned-with-no-kind.
1561
1904
file_deletion_strategy = 'keep'
1562
1905
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1563
1906
keep_files=file_deletion_strategy=='keep',
1564
force=file_deletion_strategy=='force')
1907
force=(file_deletion_strategy=='no-backup'))
1565
1908
1566
1909
1567
1910
class cmd_file_id(Command):
1568
"""Print file_id of a particular file or directory.
1911
__doc__ = """Print file_id of a particular file or directory.
1569
1912
1570
1913
The file_id is assigned when the file is first added and remains the
1571
1914
same through all revisions where the file exists, even when it is
1587
1930
1588
1931
1589
1932
class cmd_file_path(Command):
1590
"""Print path of file_ids to a file or directory.
1933
__doc__ = """Print path of file_ids to a file or directory.
1591
1934
1592
1935
This prints one line for each directory down to the target,
1593
1936
starting at the branch root.
1609
1952
1610
1953
1611
1954
class cmd_reconcile(Command):
1612
"""Reconcile bzr metadata in a branch.
1955
__doc__ = """Reconcile bzr metadata in a branch.
1613
1956
1614
1957
This can correct data mismatches that may have been caused by
1615
1958
previous ghost operations or bzr upgrades. You should only
1629
1972
1630
1973
_see_also = ['check']
1631
1974
takes_args = ['branch?']
1975
takes_options = [
1976
Option('canonicalize-chks',
1977
help='Make sure CHKs are in canonical form (repairs '
1978
'bug 522637).',
1979
hidden=True),
1980
]
1632
1981
1633
def run(self, branch="."):
1982
def run(self, branch=".", canonicalize_chks=False):
1634
1983
from bzrlib.reconcile import reconcile
1635
dir = bzrdir.BzrDir.open(branch)
1636
reconcile(dir)
1984
dir = controldir.ControlDir.open(branch)
1985
reconcile(dir, canonicalize_chks=canonicalize_chks)
1637
1986
1638
1987
1639
1988
class cmd_revision_history(Command):
1640
"""Display the list of revision ids on a branch."""
1989
__doc__ = """Display the list of revision ids on a branch."""
1641
1990
1642
1991
_see_also = ['log']
1643
1992
takes_args = ['location?']
1647
1996
@display_command
1648
1997
def run(self, location="."):
1649
1998
branch = Branch.open_containing(location)[0]
1650
for revid in branch.revision_history():
1999
self.add_cleanup(branch.lock_read().unlock)
2000
graph = branch.repository.get_graph()
2001
history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
2002
[_mod_revision.NULL_REVISION]))
2003
for revid in reversed(history):
1651
2004
self.outf.write(revid)
1652
2005
self.outf.write('\n')
1653
2006
1654
2007
1655
2008
class cmd_ancestry(Command):
1656
"""List all revisions merged into this branch."""
2009
__doc__ = """List all revisions merged into this branch."""
1657
2010
1658
2011
_see_also = ['log', 'revision-history']
1659
2012
takes_args = ['location?']
1671
2024
b = wt.branch
1672
2025
last_revision = wt.last_revision()
1673
2026
1674
revision_ids = b.repository.get_ancestry(last_revision)
1675
revision_ids.pop(0)
1676
for revision_id in revision_ids:
2027
self.add_cleanup(b.repository.lock_read().unlock)
2028
graph = b.repository.get_graph()
2029
revisions = [revid for revid, parents in
2030
graph.iter_ancestry([last_revision])]
2031
for revision_id in reversed(revisions):
2032
if _mod_revision.is_null(revision_id):
2033
continue
1677
2034
self.outf.write(revision_id + '\n')
1678
2035
1679
2036
1680
2037
class cmd_init(Command):
1681
"""Make a directory into a versioned branch.
2038
__doc__ = """Make a directory into a versioned branch.
1682
2039
1683
2040
Use this to create an empty branch, or before importing an
1684
2041
existing project.
1709
2066
RegistryOption('format',
1710
2067
help='Specify a format for this branch. '
1711
2068
'See "help formats".',
1712
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1713
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2069
lazy_registry=('bzrlib.controldir', 'format_registry'),
2070
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1714
2071
value_switches=True,
1715
2072
title="Branch format",
1716
2073
),
1717
2074
Option('append-revisions-only',
1718
2075
help='Never change revnos or the existing log.'
1719
' Append revisions to it only.')
2076
' Append revisions to it only.'),
2077
Option('no-tree',
2078
'Create a branch without a working tree.')
1720
2079
]
1721
2080
def run(self, location=None, format=None, append_revisions_only=False,
1722
create_prefix=False):
2081
create_prefix=False, no_tree=False):
1723
2082
if format is None:
1724
format = bzrdir.format_registry.make_bzrdir('default')
2083
format = controldir.format_registry.make_bzrdir('default')
1725
2084
if location is None:
1726
2085
location = u'.'
1727
2086
1736
2095
to_transport.ensure_base()
1737
2096
except errors.NoSuchFile:
1738
2097
if not create_prefix:
1739
raise errors.BzrCommandError("Parent directory of %s"
2098
raise errors.BzrCommandError(gettext("Parent directory of %s"
1740
2099
" does not exist."
1741
2100
"\nYou may supply --create-prefix to create all"
1742
" leading parent directories."
2101
" leading parent directories.")
1743
2102
% location)
1744
2103
to_transport.create_prefix()
1745
2104
1746
2105
try:
1747
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
2106
a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1748
2107
except errors.NotBranchError:
1749
2108
# really a NotBzrDir error...
1750
create_branch = bzrdir.BzrDir.create_branch_convenience
2109
create_branch = controldir.ControlDir.create_branch_convenience
2110
if no_tree:
2111
force_new_tree = False
2112
else:
2113
force_new_tree = None
1751
2114
branch = create_branch(to_transport.base, format=format,
1752
possible_transports=[to_transport])
2115
possible_transports=[to_transport],
2116
force_new_tree=force_new_tree)
1753
2117
a_bzrdir = branch.bzrdir
1754
2118
else:
1755
2119
from bzrlib.transport.local import LocalTransport
1759
2123
raise errors.BranchExistsWithoutWorkingTree(location)
1760
2124
raise errors.AlreadyBranchError(location)
1761
2125
branch = a_bzrdir.create_branch()
1762
a_bzrdir.create_workingtree()
2126
if not no_tree and not a_bzrdir.has_workingtree():
2127
a_bzrdir.create_workingtree()
1763
2128
if append_revisions_only:
1764
2129
try:
1765
2130
branch.set_append_revisions_only(True)
1766
2131
except errors.UpgradeRequired:
1767
raise errors.BzrCommandError('This branch format cannot be set'
1768
' to append-revisions-only. Try --default.')
2132
raise errors.BzrCommandError(gettext('This branch format cannot be set'
2133
' to append-revisions-only. Try --default.'))
1769
2134
if not is_quiet():
1770
2135
from bzrlib.info import describe_layout, describe_format
1771
2136
try:
1775
2140
repository = branch.repository
1776
2141
layout = describe_layout(repository, branch, tree).lower()
1777
2142
format = describe_format(a_bzrdir, repository, branch, tree)
1778
self.outf.write("Created a %s (format: %s)\n" % (layout, format))
2143
self.outf.write(gettext("Created a {0} (format: {1})\n").format(
2144
layout, format))
1779
2145
if repository.is_shared():
1780
2146
#XXX: maybe this can be refactored into transport.path_or_url()
1781
2147
url = repository.bzrdir.root_transport.external_url()
1783
2149
url = urlutils.local_path_from_url(url)
1784
2150
except errors.InvalidURL:
1785
2151
pass
1786
self.outf.write("Using shared repository: %s\n" % url)
2152
self.outf.write(gettext("Using shared repository: %s\n") % url)
1787
2153
1788
2154
1789
2155
class cmd_init_repository(Command):
1790
"""Create a shared repository for branches to share storage space.
2156
__doc__ = """Create a shared repository for branches to share storage space.
1791
2157
1792
2158
New branches created under the repository directory will store their
1793
2159
revisions in the repository, not in the branch directory. For branches
1819
2185
takes_options = [RegistryOption('format',
1820
2186
help='Specify a format for this repository. See'
1821
2187
' "bzr help formats" for details.',
1822
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1823
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2188
lazy_registry=('bzrlib.controldir', 'format_registry'),
2189
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1824
2190
value_switches=True, title='Repository format'),
1825
2191
Option('no-trees',
1826
2192
help='Branches in the repository will default to'
1830
2196
1831
2197
def run(self, location, format=None, no_trees=False):
1832
2198
if format is None:
1833
format = bzrdir.format_registry.make_bzrdir('default')
2199
format = controldir.format_registry.make_bzrdir('default')
1834
2200
1835
2201
if location is None:
1836
2202
location = '.'
1837
2203
1838
2204
to_transport = transport.get_transport(location)
1839
to_transport.ensure_base()
1840
2205
1841
newdir = format.initialize_on_transport(to_transport)
1842
repo = newdir.create_repository(shared=True)
1843
repo.set_make_working_trees(not no_trees)
2206
(repo, newdir, require_stacking, repository_policy) = (
2207
format.initialize_on_transport_ex(to_transport,
2208
create_prefix=True, make_working_trees=not no_trees,
2209
shared_repo=True, force_new_repo=True,
2210
use_existing_dir=True,
2211
repo_format_name=format.repository_format.get_format_string()))
1844
2212
if not is_quiet():
1845
2213
from bzrlib.info import show_bzrdir_info
1846
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
2214
show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1847
2215
1848
2216
1849
2217
class cmd_diff(Command):
1850
"""Show differences in the working tree, between revisions or branches.
2218
__doc__ = """Show differences in the working tree, between revisions or branches.
1851
2219
1852
2220
If no arguments are given, all changes for the current tree are listed.
1853
2221
If files are given, only the changes in those files are listed.
1859
2227
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1860
2228
produces patches suitable for "patch -p1".
1861
2229
2230
Note that when using the -r argument with a range of revisions, the
2231
differences are computed between the two specified revisions. That
2232
is, the command does not show the changes introduced by the first
2233
revision in the range. This differs from the interpretation of
2234
revision ranges used by "bzr log" which includes the first revision
2235
in the range.
2236
1862
2237
:Exit values:
1863
2238
1 - changed
1864
2239
2 - unrepresentable changes
1882
2257
1883
2258
bzr diff -r1..3 xxx
1884
2259
1885
To see the changes introduced in revision X::
2260
The changes introduced by revision 2 (equivalent to -r1..2)::
2261
2262
bzr diff -c2
2263
2264
To see the changes introduced by revision X::
1886
2265
1887
2266
bzr diff -cX
1888
2267
1892
2271
1893
2272
bzr diff -r<chosen_parent>..X
1894
2273
1895
The changes introduced by revision 2 (equivalent to -r1..2)::
2274
The changes between the current revision and the previous revision
2275
(equivalent to -c-1 and -r-2..-1)
1896
2276
1897
bzr diff -c2
2277
bzr diff -r-2..
1898
2278
1899
2279
Show just the differences for file NEWS::
1900
2280
1915
2295
Same as 'bzr diff' but prefix paths with old/ and new/::
1916
2296
1917
2297
bzr diff --prefix old/:new/
2298
2299
Show the differences using a custom diff program with options::
2300
2301
bzr diff --using /usr/bin/diff --diff-options -wu
1918
2302
"""
1919
2303
_see_also = ['status']
1920
2304
takes_args = ['file*']
1939
2323
help='Use this command to compare files.',
1940
2324
type=unicode,
1941
2325
),
2326
RegistryOption('format',
2327
short_name='F',
2328
help='Diff format to use.',
2329
lazy_registry=('bzrlib.diff', 'format_registry'),
2330
title='Diff format'),
2331
Option('context',
2332
help='How many lines of context to show.',
2333
type=int,
2334
),
1942
2335
]
1943
2336
aliases = ['di', 'dif']
1944
2337
encoding_type = 'exact'
1945
2338
1946
2339
@display_command
1947
2340
def run(self, revision=None, file_list=None, diff_options=None,
1948
prefix=None, old=None, new=None, using=None):
1949
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
2341
prefix=None, old=None, new=None, using=None, format=None,
2342
context=None):
2343
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
2344
show_diff_trees)
1950
2345
1951
2346
if (prefix is None) or (prefix == '0'):
1952
2347
# diff -p0 format
1958
2353
elif ':' in prefix:
1959
2354
old_label, new_label = prefix.split(":")
1960
2355
else:
1961
raise errors.BzrCommandError(
2356
raise errors.BzrCommandError(gettext(
1962
2357
'--prefix expects two values separated by a colon'
1963
' (eg "old/:new/")')
2358
' (eg "old/:new/")'))
1964
2359
1965
2360
if revision and len(revision) > 2:
1966
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1967
' one or two revision specifiers')
2361
raise errors.BzrCommandError(gettext('bzr diff --revision takes exactly'
2362
' one or two revision specifiers'))
2363
2364
if using is not None and format is not None:
2365
raise errors.BzrCommandError(gettext(
2366
'{0} and {1} are mutually exclusive').format(
2367
'--using', '--format'))
1968
2368
1969
2369
(old_tree, new_tree,
1970
2370
old_branch, new_branch,
1971
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1972
file_list, revision, old, new, apply_view=True)
2371
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
2372
file_list, revision, old, new, self.add_cleanup, apply_view=True)
2373
# GNU diff on Windows uses ANSI encoding for filenames
2374
path_encoding = osutils.get_diff_header_encoding()
1973
2375
return show_diff_trees(old_tree, new_tree, sys.stdout,
1974
2376
specific_files=specific_files,
1975
2377
external_diff_options=diff_options,
1976
2378
old_label=old_label, new_label=new_label,
1977
extra_trees=extra_trees, using=using)
2379
extra_trees=extra_trees,
2380
path_encoding=path_encoding,
2381
using=using, context=context,
2382
format_cls=format)
1978
2383
1979
2384
1980
2385
class cmd_deleted(Command):
1981
"""List files deleted in the working tree.
2386
__doc__ = """List files deleted in the working tree.
1982
2387
"""
1983
2388
# TODO: Show files deleted since a previous revision, or
1984
2389
# between two revisions.
1987
2392
# level of effort but possibly much less IO. (Or possibly not,
1988
2393
# if the directories are very large...)
1989
2394
_see_also = ['status', 'ls']
1990
takes_options = ['show-ids']
2395
takes_options = ['directory', 'show-ids']
1991
2396
1992
2397
@display_command
1993
def run(self, show_ids=False):
1994
tree = WorkingTree.open_containing(u'.')[0]
1995
tree.lock_read()
1996
self.add_cleanup(tree.unlock)
2398
def run(self, show_ids=False, directory=u'.'):
2399
tree = WorkingTree.open_containing(directory)[0]
2400
self.add_cleanup(tree.lock_read().unlock)
1997
2401
old = tree.basis_tree()
1998
old.lock_read()
1999
self.add_cleanup(old.unlock)
2000
for path, ie in old.inventory.iter_entries():
2402
self.add_cleanup(old.lock_read().unlock)
2403
for path, ie in old.iter_entries_by_dir():
2001
2404
if not tree.has_id(ie.file_id):
2002
2405
self.outf.write(path)
2003
2406
if show_ids:
2007
2410
2008
2411
2009
2412
class cmd_modified(Command):
2010
"""List files modified in working tree.
2413
__doc__ = """List files modified in working tree.
2011
2414
"""
2012
2415
2013
2416
hidden = True
2014
2417
_see_also = ['status', 'ls']
2015
takes_options = [
2016
Option('null',
2017
help='Write an ascii NUL (\\0) separator '
2018
'between files rather than a newline.')
2019
]
2418
takes_options = ['directory', 'null']
2020
2419
2021
2420
@display_command
2022
def run(self, null=False):
2023
tree = WorkingTree.open_containing(u'.')[0]
2421
def run(self, null=False, directory=u'.'):
2422
tree = WorkingTree.open_containing(directory)[0]
2423
self.add_cleanup(tree.lock_read().unlock)
2024
2424
td = tree.changes_from(tree.basis_tree())
2425
self.cleanup_now()
2025
2426
for path, id, kind, text_modified, meta_modified in td.modified:
2026
2427
if null:
2027
2428
self.outf.write(path + '\0')
2030
2431
2031
2432
2032
2433
class cmd_added(Command):
2033
"""List files added in working tree.
2434
__doc__ = """List files added in working tree.
2034
2435
"""
2035
2436
2036
2437
hidden = True
2037
2438
_see_also = ['status', 'ls']
2038
takes_options = [
2039
Option('null',
2040
help='Write an ascii NUL (\\0) separator '
2041
'between files rather than a newline.')
2042
]
2439
takes_options = ['directory', 'null']
2043
2440
2044
2441
@display_command
2045
def run(self, null=False):
2046
wt = WorkingTree.open_containing(u'.')[0]
2047
wt.lock_read()
2048
self.add_cleanup(wt.unlock)
2442
def run(self, null=False, directory=u'.'):
2443
wt = WorkingTree.open_containing(directory)[0]
2444
self.add_cleanup(wt.lock_read().unlock)
2049
2445
basis = wt.basis_tree()
2050
basis.lock_read()
2051
self.add_cleanup(basis.unlock)
2052
basis_inv = basis.inventory
2053
inv = wt.inventory
2054
for file_id in inv:
2055
if file_id in basis_inv:
2056
continue
2057
if inv.is_root(file_id) and len(basis_inv) == 0:
2058
continue
2059
path = inv.id2path(file_id)
2060
if not os.access(osutils.abspath(path), os.F_OK):
2446
self.add_cleanup(basis.lock_read().unlock)
2447
root_id = wt.get_root_id()
2448
for file_id in wt.all_file_ids():
2449
if basis.has_id(file_id):
2450
continue
2451
if root_id == file_id:
2452
continue
2453
path = wt.id2path(file_id)
2454
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2061
2455
continue
2062
2456
if null:
2063
2457
self.outf.write(path + '\0')
2066
2460
2067
2461
2068
2462
class cmd_root(Command):
2069
"""Show the tree root directory.
2463
__doc__ = """Show the tree root directory.
2070
2464
2071
2465
The root is the nearest enclosing directory with a .bzr control
2072
2466
directory."""
2083
2477
try:
2084
2478
return int(limitstring)
2085
2479
except ValueError:
2086
msg = "The limit argument must be an integer."
2480
msg = gettext("The limit argument must be an integer.")
2087
2481
raise errors.BzrCommandError(msg)
2088
2482
2089
2483
2091
2485
try:
2092
2486
return int(s)
2093
2487
except ValueError:
2094
msg = "The levels argument must be an integer."
2488
msg = gettext("The levels argument must be an integer.")
2095
2489
raise errors.BzrCommandError(msg)
2096
2490
2097
2491
2098
2492
class cmd_log(Command):
2099
"""Show historical log for a branch or subset of a branch.
2493
__doc__ = """Show historical log for a branch or subset of a branch.
2100
2494
2101
2495
log is bzr's default tool for exploring the history of a branch.
2102
2496
The branch to use is taken from the first parameter. If no parameters
2207
2601
2208
2602
:Other filtering:
2209
2603
2210
The --message option can be used for finding revisions that match a
2211
regular expression in a commit message.
2604
The --match option can be used for finding revisions that match a
2605
regular expression in a commit message, committer, author or bug.
2606
Specifying the option several times will match any of the supplied
2607
expressions. --match-author, --match-bugs, --match-committer and
2608
--match-message can be used to only match a specific field.
2212
2609
2213
2610
:Tips & tricks:
2214
2611
2263
2660
help='Show just the specified revision.'
2264
2661
' See also "help revisionspec".'),
2265
2662
'log-format',
2663
RegistryOption('authors',
2664
'What names to list as authors - first, all or committer.',
2665
title='Authors',
2666
lazy_registry=('bzrlib.log', 'author_list_registry'),
2667
),
2266
2668
Option('levels',
2267
2669
short_name='n',
2268
2670
help='Number of levels to display - 0 for all, 1 for flat.',
2269
2671
argname='N',
2270
2672
type=_parse_levels),
2271
2673
Option('message',
2272
short_name='m',
2273
2674
help='Show revisions whose message matches this '
2274
2675
'regular expression.',
2275
type=str),
2676
type=str,
2677
hidden=True),
2276
2678
Option('limit',
2277
2679
short_name='l',
2278
2680
help='Limit the output to the first N revisions.',
2281
2683
Option('show-diff',
2282
2684
short_name='p',
2283
2685
help='Show changes made in each revision as a patch.'),
2284
Option('include-merges',
2686
Option('include-merged',
2285
2687
help='Show merged revisions like --levels 0 does.'),
2688
Option('include-merges', hidden=True,
2689
help='Historical alias for --include-merged.'),
2690
Option('omit-merges',
2691
help='Do not report commits with more than one parent.'),
2692
Option('exclude-common-ancestry',
2693
help='Display only the revisions that are not part'
2694
' of both ancestries (require -rX..Y).'
2695
),
2696
Option('signatures',
2697
help='Show digital signature validity.'),
2698
ListOption('match',
2699
short_name='m',
2700
help='Show revisions whose properties match this '
2701
'expression.',
2702
type=str),
2703
ListOption('match-message',
2704
help='Show revisions whose message matches this '
2705
'expression.',
2706
type=str),
2707
ListOption('match-committer',
2708
help='Show revisions whose committer matches this '
2709
'expression.',
2710
type=str),
2711
ListOption('match-author',
2712
help='Show revisions whose authors match this '
2713
'expression.',
2714
type=str),
2715
ListOption('match-bugs',
2716
help='Show revisions whose bugs match this '
2717
'expression.',
2718
type=str)
2286
2719
]
2287
2720
encoding_type = 'replace'
2288
2721
2298
2731
message=None,
2299
2732
limit=None,
2300
2733
show_diff=False,
2301
include_merges=False):
2734
include_merged=None,
2735
authors=None,
2736
exclude_common_ancestry=False,
2737
signatures=False,
2738
match=None,
2739
match_message=None,
2740
match_committer=None,
2741
match_author=None,
2742
match_bugs=None,
2743
omit_merges=False,
2744
include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2745
):
2302
2746
from bzrlib.log import (
2303
2747
Logger,
2304
2748
make_log_request_dict,
2305
2749
_get_info_for_log_files,
2306
2750
)
2307
2751
direction = (forward and 'forward') or 'reverse'
2308
if include_merges:
2752
if symbol_versioning.deprecated_passed(include_merges):
2753
ui.ui_factory.show_user_warning(
2754
'deprecated_command_option',
2755
deprecated_name='--include-merges',
2756
recommended_name='--include-merged',
2757
deprecated_in_version='2.5',
2758
command=self.invoked_as)
2759
if include_merged is None:
2760
include_merged = include_merges
2761
else:
2762
raise errors.BzrCommandError(gettext(
2763
'{0} and {1} are mutually exclusive').format(
2764
'--include-merges', '--include-merged'))
2765
if include_merged is None:
2766
include_merged = False
2767
if (exclude_common_ancestry
2768
and (revision is None or len(revision) != 2)):
2769
raise errors.BzrCommandError(gettext(
2770
'--exclude-common-ancestry requires -r with two revisions'))
2771
if include_merged:
2309
2772
if levels is None:
2310
2773
levels = 0
2311
2774
else:
2312
raise errors.BzrCommandError(
2313
'--levels and --include-merges are mutually exclusive')
2775
raise errors.BzrCommandError(gettext(
2776
'{0} and {1} are mutually exclusive').format(
2777
'--levels', '--include-merged'))
2314
2778
2315
2779
if change is not None:
2316
2780
if len(change) > 1:
2317
2781
raise errors.RangeInChangeOption()
2318
2782
if revision is not None:
2319
raise errors.BzrCommandError(
2320
'--revision and --change are mutually exclusive')
2783
raise errors.BzrCommandError(gettext(
2784
'{0} and {1} are mutually exclusive').format(
2785
'--revision', '--change'))
2321
2786
else:
2322
2787
revision = change
2323
2788
2326
2791
if file_list:
2327
2792
# find the file ids to log and check for directory filtering
2328
2793
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2329
revision, file_list)
2330
self.add_cleanup(b.unlock)
2794
revision, file_list, self.add_cleanup)
2331
2795
for relpath, file_id, kind in file_info_list:
2332
2796
if file_id is None:
2333
raise errors.BzrCommandError(
2334
"Path unknown at end or start of revision range: %s" %
2797
raise errors.BzrCommandError(gettext(
2798
"Path unknown at end or start of revision range: %s") %
2335
2799
relpath)
2336
2800
# If the relpath is the top of the tree, we log everything
2337
2801
if relpath == '':
2349
2813
location = revision[0].get_branch()
2350
2814
else:
2351
2815
location = '.'
2352
dir, relpath = bzrdir.BzrDir.open_containing(location)
2816
dir, relpath = controldir.ControlDir.open_containing(location)
2353
2817
b = dir.open_branch()
2354
b.lock_read()
2355
self.add_cleanup(b.unlock)
2818
self.add_cleanup(b.lock_read().unlock)
2356
2819
rev1, rev2 = _get_revision_range(revision, b, self.name())
2357
2820
2821
if b.get_config_stack().get('validate_signatures_in_log'):
2822
signatures = True
2823
2824
if signatures:
2825
if not gpg.GPGStrategy.verify_signatures_available():
2826
raise errors.GpgmeNotInstalled(None)
2827
2358
2828
# Decide on the type of delta & diff filtering to use
2359
2829
# TODO: add an --all-files option to make this configurable & consistent
2360
2830
if not verbose:
2378
2848
show_timezone=timezone,
2379
2849
delta_format=get_verbosity_level(),
2380
2850
levels=levels,
2381
show_advice=levels is None)
2851
show_advice=levels is None,
2852
author_list_handler=authors)
2382
2853
2383
2854
# Choose the algorithm for doing the logging. It's annoying
2384
2855
# having multiple code paths like this but necessary until
2396
2867
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2397
2868
or delta_type or partial_history)
2398
2869
2870
match_dict = {}
2871
if match:
2872
match_dict[''] = match
2873
if match_message:
2874
match_dict['message'] = match_message
2875
if match_committer:
2876
match_dict['committer'] = match_committer
2877
if match_author:
2878
match_dict['author'] = match_author
2879
if match_bugs:
2880
match_dict['bugs'] = match_bugs
2881
2399
2882
# Build the LogRequest and execute it
2400
2883
if len(file_ids) == 0:
2401
2884
file_ids = None
2403
2886
direction=direction, specific_fileids=file_ids,
2404
2887
start_revision=rev1, end_revision=rev2, limit=limit,
2405
2888
message_search=message, delta_type=delta_type,
2406
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2889
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2890
exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
2891
signature=signatures, omit_merges=omit_merges,
2892
)
2407
2893
Logger(b, rqst).show(lf)
2408
2894
2409
2895
2425
2911
# b is taken from revision[0].get_branch(), and
2426
2912
# show_log will use its revision_history. Having
2427
2913
# different branches will lead to weird behaviors.
2428
raise errors.BzrCommandError(
2914
raise errors.BzrCommandError(gettext(
2429
2915
"bzr %s doesn't accept two revisions in different"
2430
" branches." % command_name)
2431
rev1 = start_spec.in_history(branch)
2916
" branches.") % command_name)
2917
if start_spec.spec is None:
2918
# Avoid loading all the history.
2919
rev1 = RevisionInfo(branch, None, None)
2920
else:
2921
rev1 = start_spec.in_history(branch)
2432
2922
# Avoid loading all of history when we know a missing
2433
2923
# end of range means the last revision ...
2434
2924
if end_spec.spec is None:
2437
2927
else:
2438
2928
rev2 = end_spec.in_history(branch)
2439
2929
else:
2440
raise errors.BzrCommandError(
2441
'bzr %s --revision takes one or two values.' % command_name)
2930
raise errors.BzrCommandError(gettext(
2931
'bzr %s --revision takes one or two values.') % command_name)
2442
2932
return rev1, rev2
2443
2933
2444
2934
2463
2953
2464
2954
2465
2955
class cmd_touching_revisions(Command):
2466
"""Return revision-ids which affected a particular file.
2956
__doc__ = """Return revision-ids which affected a particular file.
2467
2957
2468
2958
A more user-friendly interface is "bzr log FILE".
2469
2959
"""
2476
2966
tree, relpath = WorkingTree.open_containing(filename)
2477
2967
file_id = tree.path2id(relpath)
2478
2968
b = tree.branch
2479
b.lock_read()
2480
self.add_cleanup(b.unlock)
2969
self.add_cleanup(b.lock_read().unlock)
2481
2970
touching_revs = log.find_touching_revisions(b, file_id)
2482
2971
for revno, revision_id, what in touching_revs:
2483
2972
self.outf.write("%6d %s\n" % (revno, what))
2484
2973
2485
2974
2486
2975
class cmd_ls(Command):
2487
"""List files in a tree.
2976
__doc__ = """List files in a tree.
2488
2977
"""
2489
2978
2490
2979
_see_also = ['status', 'cat']
2496
2985
help='Recurse into subdirectories.'),
2497
2986
Option('from-root',
2498
2987
help='Print paths relative to the root of the branch.'),
2499
Option('unknown', help='Print unknown files.'),
2988
Option('unknown', short_name='u',
2989
help='Print unknown files.'),
2500
2990
Option('versioned', help='Print versioned files.',
2501
2991
short_name='V'),
2502
Option('ignored', help='Print ignored files.'),
2503
Option('null',
2504
help='Write an ascii NUL (\\0) separator '
2505
'between files rather than a newline.'),
2506
Option('kind',
2992
Option('ignored', short_name='i',
2993
help='Print ignored files.'),
2994
Option('kind', short_name='k',
2507
2995
help='List entries of a particular kind: file, directory, symlink.',
2508
2996
type=unicode),
2997
'null',
2509
2998
'show-ids',
2999
'directory',
2510
3000
]
2511
3001
@display_command
2512
3002
def run(self, revision=None, verbose=False,
2513
3003
recursive=False, from_root=False,
2514
3004
unknown=False, versioned=False, ignored=False,
2515
null=False, kind=None, show_ids=False, path=None):
3005
null=False, kind=None, show_ids=False, path=None, directory=None):
2516
3006
2517
3007
if kind and kind not in ('file', 'directory', 'symlink'):
2518
raise errors.BzrCommandError('invalid kind specified')
3008
raise errors.BzrCommandError(gettext('invalid kind specified'))
2519
3009
2520
3010
if verbose and null:
2521
raise errors.BzrCommandError('Cannot set both --verbose and --null')
3011
raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2522
3012
all = not (unknown or versioned or ignored)
2523
3013
2524
3014
selection = {'I':ignored, '?':unknown, 'V':versioned}
2527
3017
fs_path = '.'
2528
3018
else:
2529
3019
if from_root:
2530
raise errors.BzrCommandError('cannot specify both --from-root'
2531
' and PATH')
3020
raise errors.BzrCommandError(gettext('cannot specify both --from-root'
3021
' and PATH'))
2532
3022
fs_path = path
2533
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2534
fs_path)
3023
tree, branch, relpath = \
3024
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2535
3025
2536
3026
# Calculate the prefix to use
2537
3027
prefix = None
2550
3040
if view_files:
2551
3041
apply_view = True
2552
3042
view_str = views.view_display_str(view_files)
2553
note("Ignoring files outside view. View is %s" % view_str)
3043
note(gettext("Ignoring files outside view. View is %s") % view_str)
2554
3044
2555
tree.lock_read()
2556
self.add_cleanup(tree.unlock)
3045
self.add_cleanup(tree.lock_read().unlock)
2557
3046
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2558
3047
from_dir=relpath, recursive=recursive):
2559
3048
# Apply additional masking
2601
3090
2602
3091
2603
3092
class cmd_unknowns(Command):
2604
"""List unknown files.
3093
__doc__ = """List unknown files.
2605
3094
"""
2606
3095
2607
3096
hidden = True
2608
3097
_see_also = ['ls']
3098
takes_options = ['directory']
2609
3099
2610
3100
@display_command
2611
def run(self):
2612
for f in WorkingTree.open_containing(u'.')[0].unknowns():
3101
def run(self, directory=u'.'):
3102
for f in WorkingTree.open_containing(directory)[0].unknowns():
2613
3103
self.outf.write(osutils.quotefn(f) + '\n')
2614
3104
2615
3105
2616
3106
class cmd_ignore(Command):
2617
"""Ignore specified files or patterns.
3107
__doc__ = """Ignore specified files or patterns.
2618
3108
2619
3109
See ``bzr help patterns`` for details on the syntax of patterns.
2620
3110
2629
3119
using this command or directly by using an editor, be sure to commit
2630
3120
it.
2631
3121
3122
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
3123
the global ignore file can be found in the application data directory as
3124
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
3125
Global ignores are not touched by this command. The global ignore file
3126
can be edited directly using an editor.
3127
2632
3128
Patterns prefixed with '!' are exceptions to ignore patterns and take
2633
3129
precedence over regular ignores. Such exceptions are used to specify
2634
3130
files that should be versioned which would otherwise be ignored.
2636
3132
Patterns prefixed with '!!' act as regular ignore patterns, but have
2637
3133
precedence over the '!' exception patterns.
2638
3134
2639
Note: ignore patterns containing shell wildcards must be quoted from
2640
the shell on Unix.
3135
:Notes:
3136
3137
* Ignore patterns containing shell wildcards must be quoted from
3138
the shell on Unix.
3139
3140
* Ignore patterns starting with "#" act as comments in the ignore file.
3141
To ignore patterns that begin with that character, use the "RE:" prefix.
2641
3142
2642
3143
:Examples:
2643
3144
Ignore the top level Makefile::
2652
3153
2653
3154
bzr ignore "!special.class"
2654
3155
3156
Ignore files whose name begins with the "#" character::
3157
3158
bzr ignore "RE:^#"
3159
2655
3160
Ignore .o files under the lib directory::
2656
3161
2657
3162
bzr ignore "lib/**/*.o"
2665
3170
bzr ignore "RE:(?!debian/).*"
2666
3171
2667
3172
Ignore everything except the "local" toplevel directory,
2668
but always ignore "*~" autosave files, even under local/::
3173
but always ignore autosave files ending in ~, even under local/::
2669
3174
2670
3175
bzr ignore "*"
2671
3176
bzr ignore "!./local"
2674
3179
2675
3180
_see_also = ['status', 'ignored', 'patterns']
2676
3181
takes_args = ['name_pattern*']
2677
takes_options = [
2678
Option('old-default-rules',
2679
help='Write out the ignore rules bzr < 0.9 always used.')
3182
takes_options = ['directory',
3183
Option('default-rules',
3184
help='Display the default ignore rules that bzr uses.')
2680
3185
]
2681
3186
2682
def run(self, name_pattern_list=None, old_default_rules=None):
3187
def run(self, name_pattern_list=None, default_rules=None,
3188
directory=u'.'):
2683
3189
from bzrlib import ignores
2684
if old_default_rules is not None:
2685
# dump the rules and exit
2686
for pattern in ignores.OLD_DEFAULTS:
3190
if default_rules is not None:
3191
# dump the default rules and exit
3192
for pattern in ignores.USER_DEFAULTS:
2687
3193
self.outf.write("%s\n" % pattern)
2688
3194
return
2689
3195
if not name_pattern_list:
2690
raise errors.BzrCommandError("ignore requires at least one "
2691
"NAME_PATTERN or --old-default-rules")
3196
raise errors.BzrCommandError(gettext("ignore requires at least one "
3197
"NAME_PATTERN or --default-rules."))
2692
3198
name_pattern_list = [globbing.normalize_pattern(p)
2693
3199
for p in name_pattern_list]
3200
bad_patterns = ''
3201
bad_patterns_count = 0
3202
for p in name_pattern_list:
3203
if not globbing.Globster.is_pattern_valid(p):
3204
bad_patterns_count += 1
3205
bad_patterns += ('\n %s' % p)
3206
if bad_patterns:
3207
msg = (ngettext('Invalid ignore pattern found. %s',
3208
'Invalid ignore patterns found. %s',
3209
bad_patterns_count) % bad_patterns)
3210
ui.ui_factory.show_error(msg)
3211
raise errors.InvalidPattern('')
2694
3212
for name_pattern in name_pattern_list:
2695
3213
if (name_pattern[0] == '/' or
2696
3214
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2697
raise errors.BzrCommandError(
2698
"NAME_PATTERN should not be an absolute path")
2699
tree, relpath = WorkingTree.open_containing(u'.')
3215
raise errors.BzrCommandError(gettext(
3216
"NAME_PATTERN should not be an absolute path"))
3217
tree, relpath = WorkingTree.open_containing(directory)
2700
3218
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2701
3219
ignored = globbing.Globster(name_pattern_list)
2702
3220
matches = []
2703
tree.lock_read()
3221
self.add_cleanup(tree.lock_read().unlock)
2704
3222
for entry in tree.list_files():
2705
3223
id = entry[3]
2706
3224
if id is not None:
2707
3225
filename = entry[0]
2708
3226
if ignored.match(filename):
2709
3227
matches.append(filename)
2710
tree.unlock()
2711
3228
if len(matches) > 0:
2712
self.outf.write("Warning: the following files are version controlled and"
2713
" match your ignore pattern:\n%s"
3229
self.outf.write(gettext("Warning: the following files are version "
3230
"controlled and match your ignore pattern:\n%s"
2714
3231
"\nThese files will continue to be version controlled"
2715
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
3232
" unless you 'bzr remove' them.\n") % ("\n".join(matches),))
2716
3233
2717
3234
2718
3235
class cmd_ignored(Command):
2719
"""List ignored files and the patterns that matched them.
3236
__doc__ = """List ignored files and the patterns that matched them.
2720
3237
2721
3238
List all the ignored files and the ignore pattern that caused the file to
2722
3239
be ignored.
2728
3245
2729
3246
encoding_type = 'replace'
2730
3247
_see_also = ['ignore', 'ls']
3248
takes_options = ['directory']
2731
3249
2732
3250
@display_command
2733
def run(self):
2734
tree = WorkingTree.open_containing(u'.')[0]
2735
tree.lock_read()
2736
self.add_cleanup(tree.unlock)
3251
def run(self, directory=u'.'):
3252
tree = WorkingTree.open_containing(directory)[0]
3253
self.add_cleanup(tree.lock_read().unlock)
2737
3254
for path, file_class, kind, file_id, entry in tree.list_files():
2738
3255
if file_class != 'I':
2739
3256
continue
2743
3260
2744
3261
2745
3262
class cmd_lookup_revision(Command):
2746
"""Lookup the revision-id from a revision-number
3263
__doc__ = """Lookup the revision-id from a revision-number
2747
3264
2748
3265
:Examples:
2749
3266
bzr lookup-revision 33
2750
3267
"""
2751
3268
hidden = True
2752
3269
takes_args = ['revno']
3270
takes_options = ['directory']
2753
3271
2754
3272
@display_command
2755
def run(self, revno):
3273
def run(self, revno, directory=u'.'):
2756
3274
try:
2757
3275
revno = int(revno)
2758
3276
except ValueError:
2759
raise errors.BzrCommandError("not a valid revision-number: %r"
3277
raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
2760
3278
% revno)
2761
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
3279
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2762
3280
self.outf.write("%s\n" % revid)
2763
3281
2764
3282
2765
3283
class cmd_export(Command):
2766
"""Export current or past revision to a destination directory or archive.
3284
__doc__ = """Export current or past revision to a destination directory or archive.
2767
3285
2768
3286
If no revision is specified this exports the last committed revision.
2769
3287
2790
3308
zip .zip
2791
3309
================= =========================
2792
3310
"""
3311
encoding = 'exact'
2793
3312
takes_args = ['dest', 'branch_or_subdir?']
2794
takes_options = [
3313
takes_options = ['directory',
2795
3314
Option('format',
2796
3315
help="Type of file to export to.",
2797
3316
type=unicode),
2801
3320
Option('root',
2802
3321
type=str,
2803
3322
help="Name of the root directory inside the exported file."),
3323
Option('per-file-timestamps',
3324
help='Set modification time of files to that of the last '
3325
'revision in which it was changed.'),
3326
Option('uncommitted',
3327
help='Export the working tree contents rather than that of the '
3328
'last revision.'),
2804
3329
]
2805
3330
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2806
root=None, filters=False):
3331
root=None, filters=False, per_file_timestamps=False, uncommitted=False,
3332
directory=u'.'):
2807
3333
from bzrlib.export import export
2808
3334
2809
3335
if branch_or_subdir is None:
2810
tree = WorkingTree.open_containing(u'.')[0]
2811
b = tree.branch
2812
subdir = None
3336
branch_or_subdir = directory
3337
3338
(tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
3339
branch_or_subdir)
3340
if tree is not None:
3341
self.add_cleanup(tree.lock_read().unlock)
3342
3343
if uncommitted:
3344
if tree is None:
3345
raise errors.BzrCommandError(
3346
gettext("--uncommitted requires a working tree"))
3347
export_tree = tree
2813
3348
else:
2814
b, subdir = Branch.open_containing(branch_or_subdir)
2815
tree = None
2816
2817
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
3349
export_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2818
3350
try:
2819
export(rev_tree, dest, format, root, subdir, filtered=filters)
3351
export(export_tree, dest, format, root, subdir, filtered=filters,
3352
per_file_timestamps=per_file_timestamps)
2820
3353
except errors.NoSuchExportFormat, e:
2821
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3354
raise errors.BzrCommandError(
3355
gettext('Unsupported export format: %s') % e.format)
2822
3356
2823
3357
2824
3358
class cmd_cat(Command):
2825
"""Write the contents of a file as of a given revision to standard output.
3359
__doc__ = """Write the contents of a file as of a given revision to standard output.
2826
3360
2827
3361
If no revision is nominated, the last revision is used.
2828
3362
2831
3365
"""
2832
3366
2833
3367
_see_also = ['ls']
2834
takes_options = [
3368
takes_options = ['directory',
2835
3369
Option('name-from-revision', help='The path name in the old tree.'),
2836
3370
Option('filters', help='Apply content filters to display the '
2837
3371
'convenience form.'),
2842
3376
2843
3377
@display_command
2844
3378
def run(self, filename, revision=None, name_from_revision=False,
2845
filters=False):
3379
filters=False, directory=None):
2846
3380
if revision is not None and len(revision) != 1:
2847
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2848
" one revision specifier")
3381
raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
3382
" one revision specifier"))
2849
3383
tree, branch, relpath = \
2850
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2851
branch.lock_read()
2852
self.add_cleanup(branch.unlock)
3384
_open_directory_or_containing_tree_or_branch(filename, directory)
3385
self.add_cleanup(branch.lock_read().unlock)
2853
3386
return self._run(tree, branch, relpath, filename, revision,
2854
3387
name_from_revision, filters)
2855
3388
2858
3391
if tree is None:
2859
3392
tree = b.basis_tree()
2860
3393
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2861
rev_tree.lock_read()
2862
self.add_cleanup(rev_tree.unlock)
3394
self.add_cleanup(rev_tree.lock_read().unlock)
2863
3395
2864
3396
old_file_id = rev_tree.path2id(relpath)
2865
3397
3398
# TODO: Split out this code to something that generically finds the
3399
# best id for a path across one or more trees; it's like
3400
# find_ids_across_trees but restricted to find just one. -- mbp
3401
# 20110705.
2866
3402
if name_from_revision:
2867
3403
# Try in revision if requested
2868
3404
if old_file_id is None:
2869
raise errors.BzrCommandError(
2870
"%r is not present in revision %s" % (
3405
raise errors.BzrCommandError(gettext(
3406
"{0!r} is not present in revision {1}").format(
2871
3407
filename, rev_tree.get_revision_id()))
2872
3408
else:
2873
content = rev_tree.get_file_text(old_file_id)
3409
actual_file_id = old_file_id
2874
3410
else:
2875
3411
cur_file_id = tree.path2id(relpath)
2876
found = False
2877
if cur_file_id is not None:
2878
# Then try with the actual file id
2879
try:
2880
content = rev_tree.get_file_text(cur_file_id)
2881
found = True
2882
except errors.NoSuchId:
2883
# The actual file id didn't exist at that time
2884
pass
2885
if not found and old_file_id is not None:
2886
# Finally try with the old file id
2887
content = rev_tree.get_file_text(old_file_id)
2888
found = True
2889
if not found:
2890
# Can't be found anywhere
2891
raise errors.BzrCommandError(
2892
"%r is not present in revision %s" % (
3412
if cur_file_id is not None and rev_tree.has_id(cur_file_id):
3413
actual_file_id = cur_file_id
3414
elif old_file_id is not None:
3415
actual_file_id = old_file_id
3416
else:
3417
raise errors.BzrCommandError(gettext(
3418
"{0!r} is not present in revision {1}").format(
2893
3419
filename, rev_tree.get_revision_id()))
2894
3420
if filtered:
2895
from bzrlib.filters import (
2896
ContentFilterContext,
2897
filtered_output_bytes,
2898
)
2899
filters = rev_tree._content_filter_stack(relpath)
2900
chunks = content.splitlines(True)
2901
content = filtered_output_bytes(chunks, filters,
2902
ContentFilterContext(relpath, rev_tree))
2903
self.cleanup_now()
2904
self.outf.writelines(content)
3421
from bzrlib.filter_tree import ContentFilterTree
3422
filter_tree = ContentFilterTree(rev_tree,
3423
rev_tree._content_filter_stack)
3424
content = filter_tree.get_file_text(actual_file_id)
2905
3425
else:
2906
self.cleanup_now()
2907
self.outf.write(content)
3426
content = rev_tree.get_file_text(actual_file_id)
3427
self.cleanup_now()
3428
self.outf.write(content)
2908
3429
2909
3430
2910
3431
class cmd_local_time_offset(Command):
2911
"""Show the offset in seconds from GMT to local time."""
3432
__doc__ = """Show the offset in seconds from GMT to local time."""
2912
3433
hidden = True
2913
3434
@display_command
2914
3435
def run(self):
2917
3438
2918
3439
2919
3440
class cmd_commit(Command):
2920
"""Commit changes into a new revision.
3441
__doc__ = """Commit changes into a new revision.
2921
3442
2922
3443
An explanatory message needs to be given for each commit. This is
2923
3444
often done by using the --message option (getting the message from the
2971
3492
to trigger updates to external systems like bug trackers. The --fixes
2972
3493
option can be used to record the association between a revision and
2973
3494
one or more bugs. See ``bzr help bugs`` for details.
2974
2975
A selective commit may fail in some cases where the committed
2976
tree would be invalid. Consider::
2977
2978
bzr init foo
2979
mkdir foo/bar
2980
bzr add foo/bar
2981
bzr commit foo -m "committing foo"
2982
bzr mv foo/bar foo/baz
2983
mkdir foo/bar
2984
bzr add foo/bar
2985
bzr commit foo/bar -m "committing bar but not baz"
2986
2987
In the example above, the last commit will fail by design. This gives
2988
the user the opportunity to decide whether they want to commit the
2989
rename at the same time, separately first, or not at all. (As a general
2990
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2991
3495
"""
2992
# TODO: Run hooks on tree to-be-committed, and after commit.
2993
2994
# TODO: Strict commit that fails if there are deleted files.
2995
# (what does "deleted files" mean ??)
2996
2997
# TODO: Give better message for -s, --summary, used by tla people
2998
2999
# XXX: verbose currently does nothing
3000
3496
3001
3497
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
3002
3498
takes_args = ['selected*']
3031
3527
"the master branch until a normal commit "
3032
3528
"is performed."
3033
3529
),
3034
Option('show-diff',
3530
Option('show-diff', short_name='p',
3035
3531
help='When no message is supplied, show the diff along'
3036
3532
' with the status summary in the message editor.'),
3533
Option('lossy',
3534
help='When committing to a foreign version control '
3535
'system do not push data that can not be natively '
3536
'represented.'),
3037
3537
]
3038
3538
aliases = ['ci', 'checkin']
3039
3539
3040
3540
def _iter_bug_fix_urls(self, fixes, branch):
3541
default_bugtracker = None
3041
3542
# Configure the properties for bug fixing attributes.
3042
3543
for fixed_bug in fixes:
3043
3544
tokens = fixed_bug.split(':')
3044
if len(tokens) != 2:
3045
raise errors.BzrCommandError(
3545
if len(tokens) == 1:
3546
if default_bugtracker is None:
3547
branch_config = branch.get_config_stack()
3548
default_bugtracker = branch_config.get(
3549
"bugtracker")
3550
if default_bugtracker is None:
3551
raise errors.BzrCommandError(gettext(
3552
"No tracker specified for bug %s. Use the form "
3553
"'tracker:id' or specify a default bug tracker "
3554
"using the `bugtracker` option.\nSee "
3555
"\"bzr help bugs\" for more information on this "
3556
"feature. Commit refused.") % fixed_bug)
3557
tag = default_bugtracker
3558
bug_id = tokens[0]
3559
elif len(tokens) != 2:
3560
raise errors.BzrCommandError(gettext(
3046
3561
"Invalid bug %s. Must be in the form of 'tracker:id'. "
3047
3562
"See \"bzr help bugs\" for more information on this "
3048
"feature.\nCommit refused." % fixed_bug)
3049
tag, bug_id = tokens
3563
"feature.\nCommit refused.") % fixed_bug)
3564
else:
3565
tag, bug_id = tokens
3050
3566
try:
3051
3567
yield bugtracker.get_bug_url(tag, branch, bug_id)
3052
3568
except errors.UnknownBugTrackerAbbreviation:
3053
raise errors.BzrCommandError(
3054
'Unrecognized bug %s. Commit refused.' % fixed_bug)
3569
raise errors.BzrCommandError(gettext(
3570
'Unrecognized bug %s. Commit refused.') % fixed_bug)
3055
3571
except errors.MalformedBugIdentifier, e:
3056
raise errors.BzrCommandError(
3057
"%s\nCommit refused." % (str(e),))
3572
raise errors.BzrCommandError(gettext(
3573
"%s\nCommit refused.") % (str(e),))
3058
3574
3059
3575
def run(self, message=None, file=None, verbose=False, selected_list=None,
3060
3576
unchanged=False, strict=False, local=False, fixes=None,
3061
author=None, show_diff=False, exclude=None, commit_time=None):
3577
author=None, show_diff=False, exclude=None, commit_time=None,
3578
lossy=False):
3062
3579
from bzrlib.errors import (
3063
3580
PointlessCommit,
3064
3581
ConflictsInTree,
3067
3584
from bzrlib.msgeditor import (
3068
3585
edit_commit_message_encoded,
3069
3586
generate_commit_message_template,
3070
make_commit_message_template_encoded
3587
make_commit_message_template_encoded,
3588
set_commit_message,
3071
3589
)
3072
3590
3073
3591
commit_stamp = offset = None
3075
3593
try:
3076
3594
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3077
3595
except ValueError, e:
3078
raise errors.BzrCommandError(
3079
"Could not parse --commit-time: " + str(e))
3080
3081
# TODO: Need a blackbox test for invoking the external editor; may be
3082
# slightly problematic to run this cross-platform.
3083
3084
# TODO: do more checks that the commit will succeed before
3085
# spending the user's valuable time typing a commit message.
3596
raise errors.BzrCommandError(gettext(
3597
"Could not parse --commit-time: " + str(e)))
3086
3598
3087
3599
properties = {}
3088
3600
3089
tree, selected_list = tree_files(selected_list)
3601
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3090
3602
if selected_list == ['']:
3091
3603
# workaround - commit of root of tree should be exactly the same
3092
3604
# as just default commit in that tree, and succeed even though
3117
3629
'(use --file "%(f)s" to take commit message from that file)'
3118
3630
% { 'f': message })
3119
3631
ui.ui_factory.show_warning(warning_msg)
3632
if '\r' in message:
3633
message = message.replace('\r\n', '\n')
3634
message = message.replace('\r', '\n')
3635
if file:
3636
raise errors.BzrCommandError(gettext(
3637
"please specify either --message or --file"))
3120
3638
3121
3639
def get_message(commit_obj):
3122
3640
"""Callback to get commit message"""
3123
my_message = message
3124
if my_message is not None and '\r' in my_message:
3125
my_message = my_message.replace('\r\n', '\n')
3126
my_message = my_message.replace('\r', '\n')
3127
if my_message is None and not file:
3128
t = make_commit_message_template_encoded(tree,
3641
if file:
3642
f = open(file)
3643
try:
3644
my_message = f.read().decode(osutils.get_user_encoding())
3645
finally:
3646
f.close()
3647
elif message is not None:
3648
my_message = message
3649
else:
3650
# No message supplied: make one up.
3651
# text is the status of the tree
3652
text = make_commit_message_template_encoded(tree,
3129
3653
selected_list, diff=show_diff,
3130
3654
output_encoding=osutils.get_user_encoding())
3131
start_message = generate_commit_message_template(commit_obj)
3132
my_message = edit_commit_message_encoded(t,
3133
start_message=start_message)
3134
if my_message is None:
3135
raise errors.BzrCommandError("please specify a commit"
3136
" message with either --message or --file")
3137
elif my_message and file:
3138
raise errors.BzrCommandError(
3139
"please specify either --message or --file")
3140
if file:
3141
my_message = codecs.open(file, 'rt',
3142
osutils.get_user_encoding()).read()
3143
if my_message == "":
3144
raise errors.BzrCommandError("empty commit message specified")
3655
# start_message is the template generated from hooks
3656
# XXX: Warning - looks like hooks return unicode,
3657
# make_commit_message_template_encoded returns user encoding.
3658
# We probably want to be using edit_commit_message instead to
3659
# avoid this.
3660
my_message = set_commit_message(commit_obj)
3661
if my_message is None:
3662
start_message = generate_commit_message_template(commit_obj)
3663
my_message = edit_commit_message_encoded(text,
3664
start_message=start_message)
3665
if my_message is None:
3666
raise errors.BzrCommandError(gettext("please specify a commit"
3667
" message with either --message or --file"))
3668
if my_message == "":
3669
raise errors.BzrCommandError(gettext("Empty commit message specified."
3670
" Please specify a commit message with either"
3671
" --message or --file or leave a blank message"
3672
" with --message \"\"."))
3145
3673
return my_message
3146
3674
3147
3675
# The API permits a commit with a filter of [] to mean 'select nothing'
3155
3683
reporter=None, verbose=verbose, revprops=properties,
3156
3684
authors=author, timestamp=commit_stamp,
3157
3685
timezone=offset,
3158
exclude=safe_relpath_files(tree, exclude))
3686
exclude=tree.safe_relpath_files(exclude),
3687
lossy=lossy)
3159
3688
except PointlessCommit:
3160
# FIXME: This should really happen before the file is read in;
3161
# perhaps prepare the commit; get the message; then actually commit
3162
raise errors.BzrCommandError("No changes to commit."
3163
" Use --unchanged to commit anyhow.")
3689
raise errors.BzrCommandError(gettext("No changes to commit."
3690
" Please 'bzr add' the files you want to commit, or use"
3691
" --unchanged to force an empty commit."))
3164
3692
except ConflictsInTree:
3165
raise errors.BzrCommandError('Conflicts detected in working '
3693
raise errors.BzrCommandError(gettext('Conflicts detected in working '
3166
3694
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3167
' resolve.')
3695
' resolve.'))
3168
3696
except StrictCommitFailed:
3169
raise errors.BzrCommandError("Commit refused because there are"
3170
" unknown files in the working tree.")
3697
raise errors.BzrCommandError(gettext("Commit refused because there are"
3698
" unknown files in the working tree."))
3171
3699
except errors.BoundBranchOutOfDate, e:
3172
raise errors.BzrCommandError(str(e) + "\n"
3173
'To commit to master branch, run update and then commit.\n'
3174
'You can also pass --local to commit to continue working '
3175
'disconnected.')
3700
e.extra_help = (gettext("\n"
3701
'To commit to master branch, run update and then commit.\n'
3702
'You can also pass --local to commit to continue working '
3703
'disconnected.'))
3704
raise
3176
3705
3177
3706
3178
3707
class cmd_check(Command):
3179
"""Validate working tree structure, branch consistency and repository history.
3708
__doc__ = """Validate working tree structure, branch consistency and repository history.
3180
3709
3181
3710
This command checks various invariants about branch and repository storage
3182
3711
to detect data corruption or bzr bugs.
3246
3775
3247
3776
3248
3777
class cmd_upgrade(Command):
3249
"""Upgrade branch storage to current format.
3250
3251
The check command or bzr developers may sometimes advise you to run
3252
this command. When the default format has changed you may also be warned
3253
during other operations to upgrade.
3778
__doc__ = """Upgrade a repository, branch or working tree to a newer format.
3779
3780
When the default format has changed after a major new release of
3781
Bazaar, you may be informed during certain operations that you
3782
should upgrade. Upgrading to a newer format may improve performance
3783
or make new features available. It may however limit interoperability
3784
with older repositories or with older versions of Bazaar.
3785
3786
If you wish to upgrade to a particular format rather than the
3787
current default, that can be specified using the --format option.
3788
As a consequence, you can use the upgrade command this way to
3789
"downgrade" to an earlier format, though some conversions are
3790
a one way process (e.g. changing from the 1.x default to the
3791
2.x default) so downgrading is not always possible.
3792
3793
A backup.bzr.~#~ directory is created at the start of the conversion
3794
process (where # is a number). By default, this is left there on
3795
completion. If the conversion fails, delete the new .bzr directory
3796
and rename this one back in its place. Use the --clean option to ask
3797
for the backup.bzr directory to be removed on successful conversion.
3798
Alternatively, you can delete it by hand if everything looks good
3799
afterwards.
3800
3801
If the location given is a shared repository, dependent branches
3802
are also converted provided the repository converts successfully.
3803
If the conversion of a branch fails, remaining branches are still
3804
tried.
3805
3806
For more information on upgrades, see the Bazaar Upgrade Guide,
3807
http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3254
3808
"""
3255
3809
3256
_see_also = ['check']
3810
_see_also = ['check', 'reconcile', 'formats']
3257
3811
takes_args = ['url?']
3258
3812
takes_options = [
3259
RegistryOption('format',
3260
help='Upgrade to a specific format. See "bzr help'
3261
' formats" for details.',
3262
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3263
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3264
value_switches=True, title='Branch format'),
3265
]
3813
RegistryOption('format',
3814
help='Upgrade to a specific format. See "bzr help'
3815
' formats" for details.',
3816
lazy_registry=('bzrlib.controldir', 'format_registry'),
3817
converter=lambda name: controldir.format_registry.make_bzrdir(name),
3818
value_switches=True, title='Branch format'),
3819
Option('clean',
3820
help='Remove the backup.bzr directory if successful.'),
3821
Option('dry-run',
3822
help="Show what would be done, but don't actually do anything."),
3823
]
3266
3824
3267
def run(self, url='.', format=None):
3825
def run(self, url='.', format=None, clean=False, dry_run=False):
3268
3826
from bzrlib.upgrade import upgrade
3269
upgrade(url, format)
3827
exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3828
if exceptions:
3829
if len(exceptions) == 1:
3830
# Compatibility with historical behavior
3831
raise exceptions[0]
3832
else:
3833
return 3
3270
3834
3271
3835
3272
3836
class cmd_whoami(Command):
3273
"""Show or set bzr user id.
3837
__doc__ = """Show or set bzr user id.
3274
3838
3275
3839
:Examples:
3276
3840
Show the email of the current user::
3281
3845
3282
3846
bzr whoami "Frank Chu <fchu@example.com>"
3283
3847
"""
3284
takes_options = [ Option('email',
3848
takes_options = [ 'directory',
3849
Option('email',
3285
3850
help='Display email address only.'),
3286
3851
Option('branch',
3287
3852
help='Set identity for the current branch instead of '
3291
3856
encoding_type = 'replace'
3292
3857
3293
3858
@display_command
3294
def run(self, email=False, branch=False, name=None):
3859
def run(self, email=False, branch=False, name=None, directory=None):
3295
3860
if name is None:
3296
# use branch if we're inside one; otherwise global config
3297
try:
3298
c = Branch.open_containing('.')[0].get_config()
3299
except errors.NotBranchError:
3300
c = config.GlobalConfig()
3861
if directory is None:
3862
# use branch if we're inside one; otherwise global config
3863
try:
3864
c = Branch.open_containing(u'.')[0].get_config_stack()
3865
except errors.NotBranchError:
3866
c = _mod_config.GlobalStack()
3867
else:
3868
c = Branch.open(directory).get_config_stack()
3869
identity = c.get('email')
3301
3870
if email:
3302
self.outf.write(c.user_email() + '\n')
3871
self.outf.write(_mod_config.extract_email_address(identity)
3872
+ '\n')
3303
3873
else:
3304
self.outf.write(c.username() + '\n')
3874
self.outf.write(identity + '\n')
3305
3875
return
3306
3876
3877
if email:
3878
raise errors.BzrCommandError(gettext("--email can only be used to display existing "
3879
"identity"))
3880
3307
3881
# display a warning if an email address isn't included in the given name.
3308
3882
try:
3309
config.extract_email_address(name)
3883
_mod_config.extract_email_address(name)
3310
3884
except errors.NoEmailInUsername, e:
3311
3885
warning('"%s" does not seem to contain an email address. '
3312
3886
'This is allowed, but not recommended.', name)
3313
3887
3314
3888
# use global config unless --branch given
3315
3889
if branch:
3316
c = Branch.open_containing('.')[0].get_config()
3890
if directory is None:
3891
c = Branch.open_containing(u'.')[0].get_config_stack()
3892
else:
3893
b = Branch.open(directory)
3894
self.add_cleanup(b.lock_write().unlock)
3895
c = b.get_config_stack()
3317
3896
else:
3318
c = config.GlobalConfig()
3319
c.set_user_option('email', name)
3897
c = _mod_config.GlobalStack()
3898
c.set('email', name)
3320
3899
3321
3900
3322
3901
class cmd_nick(Command):
3323
"""Print or set the branch nickname.
3902
__doc__ = """Print or set the branch nickname.
3324
3903
3325
If unset, the tree root directory name is used as the nickname.
3326
To print the current nickname, execute with no argument.
3904
If unset, the colocated branch name is used for colocated branches, and
3905
the branch directory name is used for other branches. To print the
3906
current nickname, execute with no argument.
3327
3907
3328
3908
Bound branches use the nickname of its master branch unless it is set
3329
3909
locally.
3331
3911
3332
3912
_see_also = ['info']
3333
3913
takes_args = ['nickname?']
3334
def run(self, nickname=None):
3335
branch = Branch.open_containing(u'.')[0]
3914
takes_options = ['directory']
3915
def run(self, nickname=None, directory=u'.'):
3916
branch = Branch.open_containing(directory)[0]
3336
3917
if nickname is None:
3337
3918
self.printme(branch)
3338
3919
else:
3344
3925
3345
3926
3346
3927
class cmd_alias(Command):
3347
"""Set/unset and display aliases.
3928
__doc__ = """Set/unset and display aliases.
3348
3929
3349
3930
:Examples:
3350
3931
Show the current aliases::
3383
3964
3384
3965
def remove_alias(self, alias_name):
3385
3966
if alias_name is None:
3386
raise errors.BzrCommandError(
3387
'bzr alias --remove expects an alias to remove.')
3967
raise errors.BzrCommandError(gettext(
3968
'bzr alias --remove expects an alias to remove.'))
3388
3969
# If alias is not found, print something like:
3389
3970
# unalias: foo: not found
3390
c = config.GlobalConfig()
3971
c = _mod_config.GlobalConfig()
3391
3972
c.unset_alias(alias_name)
3392
3973
3393
3974
@display_command
3394
3975
def print_aliases(self):
3395
3976
"""Print out the defined aliases in a similar format to bash."""
3396
aliases = config.GlobalConfig().get_aliases()
3977
aliases = _mod_config.GlobalConfig().get_aliases()
3397
3978
for key, value in sorted(aliases.iteritems()):
3398
3979
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3399
3980
3409
3990
3410
3991
def set_alias(self, alias_name, alias_command):
3411
3992
"""Save the alias in the global config."""
3412
c = config.GlobalConfig()
3993
c = _mod_config.GlobalConfig()
3413
3994
c.set_alias(alias_name, alias_command)
3414
3995
3415
3996
3416
3997
class cmd_selftest(Command):
3417
"""Run internal test suite.
3998
__doc__ = """Run internal test suite.
3418
3999
3419
4000
If arguments are given, they are regular expressions that say which tests
3420
4001
should run. Tests matching any expression are run, and other tests are
3450
4031
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3451
4032
into a pdb postmortem session.
3452
4033
4034
The --coverage=DIRNAME global option produces a report with covered code
4035
indicated.
4036
3453
4037
:Examples:
3454
4038
Run only tests relating to 'ignore'::
3455
4039
3466
4050
if typestring == "sftp":
3467
4051
from bzrlib.tests import stub_sftp
3468
4052
return stub_sftp.SFTPAbsoluteServer
3469
if typestring == "memory":
4053
elif typestring == "memory":
3470
4054
from bzrlib.tests import test_server
3471
4055
return memory.MemoryServer
3472
if typestring == "fakenfs":
4056
elif typestring == "fakenfs":
3473
4057
from bzrlib.tests import test_server
3474
4058
return test_server.FakeNFSServer
3475
4059
msg = "No known transport type %s. Supported types are: sftp\n" %\
3488
4072
'throughout the test suite.',
3489
4073
type=get_transport_type),
3490
4074
Option('benchmark',
3491
help='Run the benchmarks rather than selftests.'),
4075
help='Run the benchmarks rather than selftests.',
4076
hidden=True),
3492
4077
Option('lsprof-timed',
3493
4078
help='Generate lsprof output for benchmarked'
3494
4079
' sections of code.'),
3495
4080
Option('lsprof-tests',
3496
4081
help='Generate lsprof output for each test.'),
3497
Option('cache-dir', type=str,
3498
help='Cache intermediate benchmark output in this '
3499
'directory.'),
3500
4082
Option('first',
3501
4083
help='Run all tests, but run specified tests first.',
3502
4084
short_name='f',
3511
4093
Option('randomize', type=str, argname="SEED",
3512
4094
help='Randomize the order of tests using the given'
3513
4095
' seed or "now" for the current time.'),
3514
Option('exclude', type=str, argname="PATTERN",
3515
short_name='x',
3516
help='Exclude tests that match this regular'
3517
' expression.'),
4096
ListOption('exclude', type=str, argname="PATTERN",
4097
short_name='x',
4098
help='Exclude tests that match this regular'
4099
' expression.'),
3518
4100
Option('subunit',
3519
4101
help='Output test progress via subunit.'),
3520
4102
Option('strict', help='Fail on missing dependencies or '
3527
4109
param_name='starting_with', short_name='s',
3528
4110
help=
3529
4111
'Load only the tests starting with TESTID.'),
4112
Option('sync',
4113
help="By default we disable fsync and fdatasync"
4114
" while running the test suite.")
3530
4115
]
3531
4116
encoding_type = 'replace'
3532
4117
3536
4121
3537
4122
def run(self, testspecs_list=None, verbose=False, one=False,
3538
4123
transport=None, benchmark=None,
3539
lsprof_timed=None, cache_dir=None,
4124
lsprof_timed=None,
3540
4125
first=False, list_only=False,
3541
4126
randomize=None, exclude=None, strict=False,
3542
4127
load_list=None, debugflag=None, starting_with=None, subunit=False,
3543
parallel=None, lsprof_tests=False):
3544
from bzrlib.tests import selftest
3545
import bzrlib.benchmarks as benchmarks
3546
from bzrlib.benchmarks import tree_creator
3547
3548
# Make deprecation warnings visible, unless -Werror is set
3549
symbol_versioning.activate_deprecation_warnings(override=False)
3550
3551
if cache_dir is not None:
3552
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
4128
parallel=None, lsprof_tests=False,
4129
sync=False):
4130
4131
# During selftest, disallow proxying, as it can cause severe
4132
# performance penalties and is only needed for thread
4133
# safety. The selftest command is assumed to not use threads
4134
# too heavily. The call should be as early as possible, as
4135
# error reporting for past duplicate imports won't have useful
4136
# backtraces.
4137
lazy_import.disallow_proxying()
4138
4139
from bzrlib import tests
4140
3553
4141
if testspecs_list is not None:
3554
4142
pattern = '|'.join(testspecs_list)
3555
4143
else:
3558
4146
try:
3559
4147
from bzrlib.tests import SubUnitBzrRunner
3560
4148
except ImportError:
3561
raise errors.BzrCommandError("subunit not available. subunit "
3562
"needs to be installed to use --subunit.")
4149
raise errors.BzrCommandError(gettext("subunit not available. subunit "
4150
"needs to be installed to use --subunit."))
3563
4151
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
4152
# On Windows, disable automatic conversion of '\n' to '\r\n' in
4153
# stdout, which would corrupt the subunit stream.
4154
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
4155
# following code can be deleted when it's sufficiently deployed
4156
# -- vila/mgz 20100514
4157
if (sys.platform == "win32"
4158
and getattr(sys.stdout, 'fileno', None) is not None):
4159
import msvcrt
4160
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3564
4161
if parallel:
3565
4162
self.additional_selftest_args.setdefault(
3566
4163
'suite_decorators', []).append(parallel)
3567
4164
if benchmark:
3568
test_suite_factory = benchmarks.test_suite
3569
# Unless user explicitly asks for quiet, be verbose in benchmarks
3570
verbose = not is_quiet()
3571
# TODO: should possibly lock the history file...
3572
benchfile = open(".perf_history", "at", buffering=1)
3573
self.add_cleanup(benchfile.close)
4165
raise errors.BzrCommandError(gettext(
4166
"--benchmark is no longer supported from bzr 2.2; "
4167
"use bzr-usertest instead"))
4168
test_suite_factory = None
4169
if not exclude:
4170
exclude_pattern = None
3574
4171
else:
3575
test_suite_factory = None
3576
benchfile = None
4172
exclude_pattern = '(' + '|'.join(exclude) + ')'
4173
if not sync:
4174
self._disable_fsync()
3577
4175
selftest_kwargs = {"verbose": verbose,
3578
4176
"pattern": pattern,
3579
4177
"stop_on_failure": one,
3581
4179
"test_suite_factory": test_suite_factory,
3582
4180
"lsprof_timed": lsprof_timed,
3583
4181
"lsprof_tests": lsprof_tests,
3584
"bench_history": benchfile,
3585
4182
"matching_tests_first": first,
3586
4183
"list_only": list_only,
3587
4184
"random_seed": randomize,
3588
"exclude_pattern": exclude,
4185
"exclude_pattern": exclude_pattern,
3589
4186
"strict": strict,
3590
4187
"load_list": load_list,
3591
4188
"debug_flags": debugflag,
3592
4189
"starting_with": starting_with
3593
4190
}
3594
4191
selftest_kwargs.update(self.additional_selftest_args)
3595
result = selftest(**selftest_kwargs)
4192
4193
# Make deprecation warnings visible, unless -Werror is set
4194
cleanup = symbol_versioning.activate_deprecation_warnings(
4195
override=False)
4196
try:
4197
result = tests.selftest(**selftest_kwargs)
4198
finally:
4199
cleanup()
3596
4200
return int(not result)
3597
4201
4202
def _disable_fsync(self):
4203
"""Change the 'os' functionality to not synchronize."""
4204
self._orig_fsync = getattr(os, 'fsync', None)
4205
if self._orig_fsync is not None:
4206
os.fsync = lambda filedes: None
4207
self._orig_fdatasync = getattr(os, 'fdatasync', None)
4208
if self._orig_fdatasync is not None:
4209
os.fdatasync = lambda filedes: None
4210
3598
4211
3599
4212
class cmd_version(Command):
3600
"""Show version of bzr."""
4213
__doc__ = """Show version of bzr."""
3601
4214
3602
4215
encoding_type = 'replace'
3603
4216
takes_options = [
3614
4227
3615
4228
3616
4229
class cmd_rocks(Command):
3617
"""Statement of optimism."""
4230
__doc__ = """Statement of optimism."""
3618
4231
3619
4232
hidden = True
3620
4233
3621
4234
@display_command
3622
4235
def run(self):
3623
self.outf.write("It sure does!\n")
4236
self.outf.write(gettext("It sure does!\n"))
3624
4237
3625
4238
3626
4239
class cmd_find_merge_base(Command):
3627
"""Find and print a base revision for merging two branches."""
4240
__doc__ = """Find and print a base revision for merging two branches."""
3628
4241
# TODO: Options to specify revisions on either side, as if
3629
4242
# merging only part of the history.
3630
4243
takes_args = ['branch', 'other']
3636
4249
3637
4250
branch1 = Branch.open_containing(branch)[0]
3638
4251
branch2 = Branch.open_containing(other)[0]
3639
branch1.lock_read()
3640
self.add_cleanup(branch1.unlock)
3641
branch2.lock_read()
3642
self.add_cleanup(branch2.unlock)
4252
self.add_cleanup(branch1.lock_read().unlock)
4253
self.add_cleanup(branch2.lock_read().unlock)
3643
4254
last1 = ensure_null(branch1.last_revision())
3644
4255
last2 = ensure_null(branch2.last_revision())
3645
4256
3646
4257
graph = branch1.repository.get_graph(branch2.repository)
3647
4258
base_rev_id = graph.find_unique_lca(last1, last2)
3648
4259
3649
self.outf.write('merge base is revision %s\n' % base_rev_id)
4260
self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
3650
4261
3651
4262
3652
4263
class cmd_merge(Command):
3653
"""Perform a three-way merge.
4264
__doc__ = """Perform a three-way merge.
3654
4265
3655
4266
The source of the merge can be specified either in the form of a branch,
3656
4267
or in the form of a path to a file containing a merge directive generated
3657
4268
with bzr send. If neither is specified, the default is the upstream branch
3658
or the branch most recently merged using --remember.
3659
3660
When merging a branch, by default the tip will be merged. To pick a different
3661
revision, pass --revision. If you specify two values, the first will be used as
3662
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3663
available revisions, like this is commonly referred to as "cherrypicking".
3664
3665
Revision numbers are always relative to the branch being merged.
3666
3667
By default, bzr will try to merge in all new work from the other
3668
branch, automatically determining an appropriate base. If this
3669
fails, you may need to give an explicit base.
4269
or the branch most recently merged using --remember. The source of the
4270
merge may also be specified in the form of a path to a file in another
4271
branch: in this case, only the modifications to that file are merged into
4272
the current working tree.
4273
4274
When merging from a branch, by default bzr will try to merge in all new
4275
work from the other branch, automatically determining an appropriate base
4276
revision. If this fails, you may need to give an explicit base.
4277
4278
To pick a different ending revision, pass "--revision OTHER". bzr will
4279
try to merge in all new work up to and including revision OTHER.
4280
4281
If you specify two values, "--revision BASE..OTHER", only revisions BASE
4282
through OTHER, excluding BASE but including OTHER, will be merged. If this
4283
causes some revisions to be skipped, i.e. if the destination branch does
4284
not already contain revision BASE, such a merge is commonly referred to as
4285
a "cherrypick". Unlike a normal merge, Bazaar does not currently track
4286
cherrypicks. The changes look like a normal commit, and the history of the
4287
changes from the other branch is not stored in the commit.
4288
4289
Revision numbers are always relative to the source branch.
3670
4290
3671
4291
Merge will do its best to combine the changes in two branches, but there
3672
4292
are some kinds of problems only a human can fix. When it encounters those,
3673
4293
it will mark a conflict. A conflict means that you need to fix something,
3674
before you should commit.
4294
before you can commit.
3675
4295
3676
4296
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3677
4297
3678
If there is no default branch set, the first merge will set it. After
3679
that, you can omit the branch to use the default. To change the
3680
default, use --remember. The value will only be saved if the remote
3681
location can be accessed.
4298
If there is no default branch set, the first merge will set it (use
4299
--no-remember to avoid setting it). After that, you can omit the branch
4300
to use the default. To change the default, use --remember. The value will
4301
only be saved if the remote location can be accessed.
3682
4302
3683
4303
The results of the merge are placed into the destination working
3684
4304
directory, where they can be reviewed (with bzr diff), tested, and then
3685
4305
committed to record the result of the merge.
3686
4306
3687
4307
merge refuses to run if there are any uncommitted changes, unless
3688
--force is given. The --force option can also be used to create a
4308
--force is given. If --force is given, then the changes from the source
4309
will be merged with the current working tree, including any uncommitted
4310
changes in the tree. The --force option can also be used to create a
3689
4311
merge revision which has more than two parents.
3690
4312
3691
4313
If one would like to merge changes from the working tree of the other
3696
4318
you to apply each diff hunk and file change, similar to "shelve".
3697
4319
3698
4320
:Examples:
3699
To merge the latest revision from bzr.dev::
4321
To merge all new revisions from bzr.dev::
3700
4322
3701
4323
bzr merge ../bzr.dev
3702
4324
3739
4361
' completely merged into the source, pull from the'
3740
4362
' source rather than merging. When this happens,'
3741
4363
' you do not need to commit the result.'),
3742
Option('directory',
4364
custom_help('directory',
3743
4365
help='Branch to merge into, '
3744
'rather than the one containing the working directory.',
3745
short_name='d',
3746
type=unicode,
3747
),
4366
'rather than the one containing the working directory.'),
3748
4367
Option('preview', help='Instead of merging, show a diff of the'
3749
4368
' merge.'),
3750
4369
Option('interactive', help='Select changes interactively.',
3752
4371
]
3753
4372
3754
4373
def run(self, location=None, revision=None, force=False,
3755
merge_type=None, show_base=False, reprocess=None, remember=False,
4374
merge_type=None, show_base=False, reprocess=None, remember=None,
3756
4375
uncommitted=False, pull=False,
3757
4376
directory=None,
3758
4377
preview=False,
3766
4385
merger = None
3767
4386
allow_pending = True
3768
4387
verified = 'inapplicable'
4388
3769
4389
tree = WorkingTree.open_containing(directory)[0]
4390
if tree.branch.revno() == 0:
4391
raise errors.BzrCommandError(gettext('Merging into empty branches not currently supported, '
4392
'https://bugs.launchpad.net/bzr/+bug/308562'))
3770
4393
3771
4394
try:
3772
4395
basis_tree = tree.revision_tree(tree.last_revision())
3783
4406
unversioned_filter=tree.is_ignored, view_info=view_info)
3784
4407
pb = ui.ui_factory.nested_progress_bar()
3785
4408
self.add_cleanup(pb.finished)
3786
tree.lock_write()
3787
self.add_cleanup(tree.unlock)
4409
self.add_cleanup(tree.lock_write().unlock)
3788
4410
if location is not None:
3789
4411
try:
3790
4412
mergeable = bundle.read_mergeable_from_url(location,
3793
4415
mergeable = None
3794
4416
else:
3795
4417
if uncommitted:
3796
raise errors.BzrCommandError('Cannot use --uncommitted'
3797
' with bundles or merge directives.')
4418
raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
4419
' with bundles or merge directives.'))
3798
4420
3799
4421
if revision is not None:
3800
raise errors.BzrCommandError(
3801
'Cannot use -r with merge directives or bundles')
4422
raise errors.BzrCommandError(gettext(
4423
'Cannot use -r with merge directives or bundles'))
3802
4424
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3803
4425
mergeable, None)
3804
4426
3805
4427
if merger is None and uncommitted:
3806
4428
if revision is not None and len(revision) > 0:
3807
raise errors.BzrCommandError('Cannot use --uncommitted and'
3808
' --revision at the same time.')
4429
raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
4430
' --revision at the same time.'))
3809
4431
merger = self.get_merger_from_uncommitted(tree, location, None)
3810
4432
allow_pending = False
3811
4433
3819
4441
self.sanity_check_merger(merger)
3820
4442
if (merger.base_rev_id == merger.other_rev_id and
3821
4443
merger.other_rev_id is not None):
3822
note('Nothing to do.')
4444
# check if location is a nonexistent file (and not a branch) to
4445
# disambiguate the 'Nothing to do'
4446
if merger.interesting_files:
4447
if not merger.other_tree.has_filename(
4448
merger.interesting_files[0]):
4449
note(gettext("merger: ") + str(merger))
4450
raise errors.PathsDoNotExist([location])
4451
note(gettext('Nothing to do.'))
3823
4452
return 0
3824
if pull:
4453
if pull and not preview:
3825
4454
if merger.interesting_files is not None:
3826
raise errors.BzrCommandError('Cannot pull individual files')
4455
raise errors.BzrCommandError(gettext('Cannot pull individual files'))
3827
4456
if (merger.base_rev_id == tree.last_revision()):
3828
4457
result = tree.pull(merger.other_branch, False,
3829
4458
merger.other_rev_id)
3830
4459
result.report(self.outf)
3831
4460
return 0
3832
4461
if merger.this_basis is None:
3833
raise errors.BzrCommandError(
4462
raise errors.BzrCommandError(gettext(
3834
4463
"This branch has no commits."
3835
" (perhaps you would prefer 'bzr pull')")
4464
" (perhaps you would prefer 'bzr pull')"))
3836
4465
if preview:
3837
4466
return self._do_preview(merger)
3838
4467
elif interactive:
3851
4480
def _do_preview(self, merger):
3852
4481
from bzrlib.diff import show_diff_trees
3853
4482
result_tree = self._get_preview(merger)
4483
path_encoding = osutils.get_diff_header_encoding()
3854
4484
show_diff_trees(merger.this_tree, result_tree, self.outf,
3855
old_label='', new_label='')
4485
old_label='', new_label='',
4486
path_encoding=path_encoding)
3856
4487
3857
4488
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3858
4489
merger.change_reporter = change_reporter
3887
4518
def sanity_check_merger(self, merger):
3888
4519
if (merger.show_base and
3889
4520
not merger.merge_type is _mod_merge.Merge3Merger):
3890
raise errors.BzrCommandError("Show-base is not supported for this"
3891
" merge type. %s" % merger.merge_type)
4521
raise errors.BzrCommandError(gettext("Show-base is not supported for this"
4522
" merge type. %s") % merger.merge_type)
3892
4523
if merger.reprocess is None:
3893
4524
if merger.show_base:
3894
4525
merger.reprocess = False
3896
4527
# Use reprocess if the merger supports it
3897
4528
merger.reprocess = merger.merge_type.supports_reprocess
3898
4529
if merger.reprocess and not merger.merge_type.supports_reprocess:
3899
raise errors.BzrCommandError("Conflict reduction is not supported"
3900
" for merge type %s." %
4530
raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
4531
" for merge type %s.") %
3901
4532
merger.merge_type)
3902
4533
if merger.reprocess and merger.show_base:
3903
raise errors.BzrCommandError("Cannot do conflict reduction and"
3904
" show base.")
4534
raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
4535
" show base."))
3905
4536
3906
4537
def _get_merger_from_branch(self, tree, location, revision, remember,
3907
4538
possible_transports, pb):
3934
4565
if other_revision_id is None:
3935
4566
other_revision_id = _mod_revision.ensure_null(
3936
4567
other_branch.last_revision())
3937
# Remember where we merge from
3938
if ((remember or tree.branch.get_submit_branch() is None) and
3939
user_location is not None):
4568
# Remember where we merge from. We need to remember if:
4569
# - user specify a location (and we don't merge from the parent
4570
# branch)
4571
# - user ask to remember or there is no previous location set to merge
4572
# from and user didn't ask to *not* remember
4573
if (user_location is not None
4574
and ((remember
4575
or (remember is None
4576
and tree.branch.get_submit_branch() is None)))):
3940
4577
tree.branch.set_submit_branch(other_branch.base)
3941
_merge_tags_if_possible(other_branch, tree.branch)
4578
# Merge tags (but don't set them in the master branch yet, the user
4579
# might revert this merge). Commit will propagate them.
4580
_merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3942
4581
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3943
4582
other_revision_id, base_revision_id, other_branch, base_branch)
3944
4583
if other_path != '':
4003
4642
stored_location_type = "parent"
4004
4643
mutter("%s", stored_location)
4005
4644
if stored_location is None:
4006
raise errors.BzrCommandError("No location specified or remembered")
4645
raise errors.BzrCommandError(gettext("No location specified or remembered"))
4007
4646
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4008
note(u"%s remembered %s location %s", verb_string,
4009
stored_location_type, display_url)
4647
note(gettext("{0} remembered {1} location {2}").format(verb_string,
4648
stored_location_type, display_url))
4010
4649
return stored_location
4011
4650
4012
4651
4013
4652
class cmd_remerge(Command):
4014
"""Redo a merge.
4653
__doc__ = """Redo a merge.
4015
4654
4016
4655
Use this if you want to try a different merge technique while resolving
4017
4656
conflicts. Some merge techniques are better than others, and remerge
4042
4681
4043
4682
def run(self, file_list=None, merge_type=None, show_base=False,
4044
4683
reprocess=False):
4684
from bzrlib.conflicts import restore
4045
4685
if merge_type is None:
4046
4686
merge_type = _mod_merge.Merge3Merger
4047
tree, file_list = tree_files(file_list)
4048
tree.lock_write()
4049
self.add_cleanup(tree.unlock)
4687
tree, file_list = WorkingTree.open_containing_paths(file_list)
4688
self.add_cleanup(tree.lock_write().unlock)
4050
4689
parents = tree.get_parent_ids()
4051
4690
if len(parents) != 2:
4052
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4691
raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4053
4692
" merges. Not cherrypicking or"
4054
" multi-merges.")
4693
" multi-merges."))
4055
4694
repository = tree.branch.repository
4056
4695
interesting_ids = None
4057
4696
new_conflicts = []
4066
4705
if tree.kind(file_id) != "directory":
4067
4706
continue
4068
4707
4069
for name, ie in tree.inventory.iter_entries(file_id):
4708
# FIXME: Support nested trees
4709
for name, ie in tree.root_inventory.iter_entries(file_id):
4070
4710
interesting_ids.add(ie.file_id)
4071
4711
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4072
4712
else:
4105
4745
4106
4746
4107
4747
class cmd_revert(Command):
4108
"""Revert files to a previous revision.
4748
__doc__ = """\
4749
Set files in the working tree back to the contents of a previous revision.
4109
4750
4110
4751
Giving a list of files will revert only those files. Otherwise, all files
4111
4752
will be reverted. If the revision is not specified with '--revision', the
4112
last committed revision is used.
4753
working tree basis revision is used. A revert operation affects only the
4754
working tree, not any revision history like the branch and repository or
4755
the working tree basis revision.
4113
4756
4114
4757
To remove only some changes, without reverting to a prior version, use
4115
merge instead. For example, "merge . --revision -2..-3" will remove the
4116
changes introduced by -2, without affecting the changes introduced by -1.
4117
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4758
merge instead. For example, "merge . -r -2..-3" (don't forget the ".")
4759
will remove the changes introduced by the second last commit (-2), without
4760
affecting the changes introduced by the last commit (-1). To remove
4761
certain changes on a hunk-by-hunk basis, see the shelve command.
4762
To update the branch to a specific revision or the latest revision and
4763
update the working tree accordingly while preserving local changes, see the
4764
update command.
4118
4765
4119
By default, any files that have been manually changed will be backed up
4120
first. (Files changed only by merge are not backed up.) Backup files have
4121
'.~#~' appended to their name, where # is a number.
4766
Uncommitted changes to files that are reverted will be discarded.
4767
Howver, by default, any files that have been manually changed will be
4768
backed up first. (Files changed only by merge are not backed up.) Backup
4769
files have '.~#~' appended to their name, where # is a number.
4122
4770
4123
4771
When you provide files, you can use their current pathname or the pathname
4124
4772
from the target revision. So you can use revert to "undelete" a file by
4150
4798
target branches.
4151
4799
"""
4152
4800
4153
_see_also = ['cat', 'export']
4801
_see_also = ['cat', 'export', 'merge', 'shelve']
4154
4802
takes_options = [
4155
4803
'revision',
4156
4804
Option('no-backup', "Do not save backups of reverted files."),
4161
4809
4162
4810
def run(self, revision=None, no_backup=False, file_list=None,
4163
4811
forget_merges=None):
4164
tree, file_list = tree_files(file_list)
4165
tree.lock_write()
4166
self.add_cleanup(tree.unlock)
4812
tree, file_list = WorkingTree.open_containing_paths(file_list)
4813
self.add_cleanup(tree.lock_tree_write().unlock)
4167
4814
if forget_merges:
4168
4815
tree.set_parent_ids(tree.get_parent_ids()[:1])
4169
4816
else:
4177
4824
4178
4825
4179
4826
class cmd_assert_fail(Command):
4180
"""Test reporting of assertion failures"""
4827
__doc__ = """Test reporting of assertion failures"""
4181
4828
# intended just for use in testing
4182
4829
4183
4830
hidden = True
4187
4834
4188
4835
4189
4836
class cmd_help(Command):
4190
"""Show help on a command or other topic.
4837
__doc__ = """Show help on a command or other topic.
4191
4838
"""
4192
4839
4193
4840
_see_also = ['topics']
4206
4853
4207
4854
4208
4855
class cmd_shell_complete(Command):
4209
"""Show appropriate completions for context.
4856
__doc__ = """Show appropriate completions for context.
4210
4857
4211
4858
For a list of all available commands, say 'bzr shell-complete'.
4212
4859
"""
4216
4863
4217
4864
@display_command
4218
4865
def run(self, context=None):
4219
import shellcomplete
4866
from bzrlib import shellcomplete
4220
4867
shellcomplete.shellcomplete(context)
4221
4868
4222
4869
4223
4870
class cmd_missing(Command):
4224
"""Show unmerged/unpulled revisions between two branches.
4871
__doc__ = """Show unmerged/unpulled revisions between two branches.
4225
4872
4226
4873
OTHER_BRANCH may be local or remote.
4227
4874
4258
4905
_see_also = ['merge', 'pull']
4259
4906
takes_args = ['other_branch?']
4260
4907
takes_options = [
4908
'directory',
4261
4909
Option('reverse', 'Reverse the order of revisions.'),
4262
4910
Option('mine-only',
4263
4911
'Display changes in the local branch only.'),
4275
4923
type=_parse_revision_str,
4276
4924
help='Filter on local branch revisions (inclusive). '
4277
4925
'See "help revisionspec" for details.'),
4278
Option('include-merges',
4926
Option('include-merged',
4279
4927
'Show all revisions in addition to the mainline ones.'),
4928
Option('include-merges', hidden=True,
4929
help='Historical alias for --include-merged.'),
4280
4930
]
4281
4931
encoding_type = 'replace'
4282
4932
4285
4935
theirs_only=False,
4286
4936
log_format=None, long=False, short=False, line=False,
4287
4937
show_ids=False, verbose=False, this=False, other=False,
4288
include_merges=False, revision=None, my_revision=None):
4938
include_merged=None, revision=None, my_revision=None,
4939
directory=u'.',
4940
include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4289
4941
from bzrlib.missing import find_unmerged, iter_log_revisions
4290
4942
def message(s):
4291
4943
if not is_quiet():
4292
4944
self.outf.write(s)
4293
4945
4946
if symbol_versioning.deprecated_passed(include_merges):
4947
ui.ui_factory.show_user_warning(
4948
'deprecated_command_option',
4949
deprecated_name='--include-merges',
4950
recommended_name='--include-merged',
4951
deprecated_in_version='2.5',
4952
command=self.invoked_as)
4953
if include_merged is None:
4954
include_merged = include_merges
4955
else:
4956
raise errors.BzrCommandError(gettext(
4957
'{0} and {1} are mutually exclusive').format(
4958
'--include-merges', '--include-merged'))
4959
if include_merged is None:
4960
include_merged = False
4294
4961
if this:
4295
4962
mine_only = this
4296
4963
if other:
4304
4971
elif theirs_only:
4305
4972
restrict = 'remote'
4306
4973
4307
local_branch = Branch.open_containing(u".")[0]
4974
local_branch = Branch.open_containing(directory)[0]
4975
self.add_cleanup(local_branch.lock_read().unlock)
4976
4308
4977
parent = local_branch.get_parent()
4309
4978
if other_branch is None:
4310
4979
other_branch = parent
4311
4980
if other_branch is None:
4312
raise errors.BzrCommandError("No peer location known"
4313
" or specified.")
4981
raise errors.BzrCommandError(gettext("No peer location known"
4982
" or specified."))
4314
4983
display_url = urlutils.unescape_for_display(parent,
4315
4984
self.outf.encoding)
4316
message("Using saved parent location: "
4317
+ display_url + "\n")
4985
message(gettext("Using saved parent location: {0}\n").format(
4986
display_url))
4318
4987
4319
4988
remote_branch = Branch.open(other_branch)
4320
4989
if remote_branch.base == local_branch.base:
4321
4990
remote_branch = local_branch
4991
else:
4992
self.add_cleanup(remote_branch.lock_read().unlock)
4322
4993
4323
local_branch.lock_read()
4324
self.add_cleanup(local_branch.unlock)
4325
4994
local_revid_range = _revision_range_to_revid_range(
4326
4995
_get_revision_range(my_revision, local_branch,
4327
4996
self.name()))
4328
4997
4329
remote_branch.lock_read()
4330
self.add_cleanup(remote_branch.unlock)
4331
4998
remote_revid_range = _revision_range_to_revid_range(
4332
4999
_get_revision_range(revision,
4333
5000
remote_branch, self.name()))
4335
5002
local_extra, remote_extra = find_unmerged(
4336
5003
local_branch, remote_branch, restrict,
4337
5004
backward=not reverse,
4338
include_merges=include_merges,
5005
include_merged=include_merged,
4339
5006
local_revid_range=local_revid_range,
4340
5007
remote_revid_range=remote_revid_range)
4341
5008
4348
5015
4349
5016
status_code = 0
4350
5017
if local_extra and not theirs_only:
4351
message("You have %d extra revision(s):\n" %
5018
message(ngettext("You have %d extra revision:\n",
5019
"You have %d extra revisions:\n",
5020
len(local_extra)) %
4352
5021
len(local_extra))
5022
rev_tag_dict = {}
5023
if local_branch.supports_tags():
5024
rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
4353
5025
for revision in iter_log_revisions(local_extra,
4354
5026
local_branch.repository,
4355
verbose):
5027
verbose,
5028
rev_tag_dict):
4356
5029
lf.log_revision(revision)
4357
5030
printed_local = True
4358
5031
status_code = 1
4362
5035
if remote_extra and not mine_only:
4363
5036
if printed_local is True:
4364
5037
message("\n\n\n")
4365
message("You are missing %d revision(s):\n" %
5038
message(ngettext("You are missing %d revision:\n",
5039
"You are missing %d revisions:\n",
5040
len(remote_extra)) %
4366
5041
len(remote_extra))
5042
if remote_branch.supports_tags():
5043
rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
4367
5044
for revision in iter_log_revisions(remote_extra,
4368
5045
remote_branch.repository,
4369
verbose):
5046
verbose,
5047
rev_tag_dict):
4370
5048
lf.log_revision(revision)
4371
5049
status_code = 1
4372
5050
4373
5051
if mine_only and not local_extra:
4374
5052
# We checked local, and found nothing extra
4375
message('This branch is up to date.\n')
5053
message(gettext('This branch has no new revisions.\n'))
4376
5054
elif theirs_only and not remote_extra:
4377
5055
# We checked remote, and found nothing extra
4378
message('Other branch is up to date.\n')
5056
message(gettext('Other branch has no new revisions.\n'))
4379
5057
elif not (mine_only or theirs_only or local_extra or
4380
5058
remote_extra):
4381
5059
# We checked both branches, and neither one had extra
4382
5060
# revisions
4383
message("Branches are up to date.\n")
5061
message(gettext("Branches are up to date.\n"))
4384
5062
self.cleanup_now()
4385
5063
if not status_code and parent is None and other_branch is not None:
4386
local_branch.lock_write()
4387
self.add_cleanup(local_branch.unlock)
5064
self.add_cleanup(local_branch.lock_write().unlock)
4388
5065
# handle race conditions - a parent might be set while we run.
4389
5066
if local_branch.get_parent() is None:
4390
5067
local_branch.set_parent(remote_branch.base)
4392
5069
4393
5070
4394
5071
class cmd_pack(Command):
4395
"""Compress the data within a repository."""
5072
__doc__ = """Compress the data within a repository.
5073
5074
This operation compresses the data within a bazaar repository. As
5075
bazaar supports automatic packing of repository, this operation is
5076
normally not required to be done manually.
5077
5078
During the pack operation, bazaar takes a backup of existing repository
5079
data, i.e. pack files. This backup is eventually removed by bazaar
5080
automatically when it is safe to do so. To save disk space by removing
5081
the backed up pack files, the --clean-obsolete-packs option may be
5082
used.
5083
5084
Warning: If you use --clean-obsolete-packs and your machine crashes
5085
during or immediately after repacking, you may be left with a state
5086
where the deletion has been written to disk but the new packs have not
5087
been. In this case the repository may be unusable.
5088
"""
4396
5089
4397
5090
_see_also = ['repositories']
4398
5091
takes_args = ['branch_or_repo?']
5092
takes_options = [
5093
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
5094
]
4399
5095
4400
def run(self, branch_or_repo='.'):
4401
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
5096
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
5097
dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
4402
5098
try:
4403
5099
branch = dir.open_branch()
4404
5100
repository = branch.repository
4405
5101
except errors.NotBranchError:
4406
5102
repository = dir.open_repository()
4407
repository.pack()
5103
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4408
5104
4409
5105
4410
5106
class cmd_plugins(Command):
4411
"""List the installed plugins.
5107
__doc__ = """List the installed plugins.
4412
5108
4413
5109
This command displays the list of installed plugins including
4414
5110
version of plugin and a short description of each.
4430
5126
4431
5127
@display_command
4432
5128
def run(self, verbose=False):
4433
import bzrlib.plugin
4434
from inspect import getdoc
4435
result = []
4436
for name, plugin in bzrlib.plugin.plugins().items():
4437
version = plugin.__version__
4438
if version == 'unknown':
4439
version = ''
4440
name_ver = '%s %s' % (name, version)
4441
d = getdoc(plugin.module)
4442
if d:
4443
doc = d.split('\n')[0]
4444
else:
4445
doc = '(no description)'
4446
result.append((name_ver, doc, plugin.path()))
4447
for name_ver, doc, path in sorted(result):
4448
self.outf.write("%s\n" % name_ver)
4449
self.outf.write(" %s\n" % doc)
4450
if verbose:
4451
self.outf.write(" %s\n" % path)
4452
self.outf.write("\n")
5129
from bzrlib import plugin
5130
# Don't give writelines a generator as some codecs don't like that
5131
self.outf.writelines(
5132
list(plugin.describe_plugins(show_paths=verbose)))
4453
5133
4454
5134
4455
5135
class cmd_testament(Command):
4456
"""Show testament (signing-form) of a revision."""
5136
__doc__ = """Show testament (signing-form) of a revision."""
4457
5137
takes_options = [
4458
5138
'revision',
4459
5139
Option('long', help='Produce long-format testament.'),
4460
5140
Option('strict',
4461
5141
help='Produce a strict-format testament.')]
4462
5142
takes_args = ['branch?']
5143
encoding_type = 'exact'
4463
5144
@display_command
4464
5145
def run(self, branch=u'.', revision=None, long=False, strict=False):
4465
5146
from bzrlib.testament import Testament, StrictTestament
4471
5152
b = Branch.open_containing(branch)[0]
4472
5153
else:
4473
5154
b = Branch.open(branch)
4474
b.lock_read()
4475
self.add_cleanup(b.unlock)
5155
self.add_cleanup(b.lock_read().unlock)
4476
5156
if revision is None:
4477
5157
rev_id = b.last_revision()
4478
5158
else:
4479
5159
rev_id = revision[0].as_revision_id(b)
4480
5160
t = testament_class.from_revision(b.repository, rev_id)
4481
5161
if long:
4482
sys.stdout.writelines(t.as_text_lines())
5162
self.outf.writelines(t.as_text_lines())
4483
5163
else:
4484
sys.stdout.write(t.as_short_text())
5164
self.outf.write(t.as_short_text())
4485
5165
4486
5166
4487
5167
class cmd_annotate(Command):
4488
"""Show the origin of each line in a file.
5168
__doc__ = """Show the origin of each line in a file.
4489
5169
4490
5170
This prints out the given file with an annotation on the left side
4491
5171
indicating which revision, author and date introduced the change.
4502
5182
Option('long', help='Show commit date in annotations.'),
4503
5183
'revision',
4504
5184
'show-ids',
5185
'directory',
4505
5186
]
4506
5187
encoding_type = 'exact'
4507
5188
4508
5189
@display_command
4509
5190
def run(self, filename, all=False, long=False, revision=None,
4510
show_ids=False):
4511
from bzrlib.annotate import annotate_file, annotate_file_tree
5191
show_ids=False, directory=None):
5192
from bzrlib.annotate import (
5193
annotate_file_tree,
5194
)
4512
5195
wt, branch, relpath = \
4513
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
5196
_open_directory_or_containing_tree_or_branch(filename, directory)
4514
5197
if wt is not None:
4515
wt.lock_read()
4516
self.add_cleanup(wt.unlock)
5198
self.add_cleanup(wt.lock_read().unlock)
4517
5199
else:
4518
branch.lock_read()
4519
self.add_cleanup(branch.unlock)
5200
self.add_cleanup(branch.lock_read().unlock)
4520
5201
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4521
tree.lock_read()
4522
self.add_cleanup(tree.unlock)
4523
if wt is not None:
5202
self.add_cleanup(tree.lock_read().unlock)
5203
if wt is not None and revision is None:
4524
5204
file_id = wt.path2id(relpath)
4525
5205
else:
4526
5206
file_id = tree.path2id(relpath)
4527
5207
if file_id is None:
4528
5208
raise errors.NotVersionedError(filename)
4529
file_version = tree.inventory[file_id].revision
4530
5209
if wt is not None and revision is None:
4531
5210
# If there is a tree and we're not annotating historical
4532
5211
# versions, annotate the working tree's content.
4533
5212
annotate_file_tree(wt, file_id, self.outf, long, all,
4534
5213
show_ids=show_ids)
4535
5214
else:
4536
annotate_file(branch, file_version, file_id, long, all, self.outf,
4537
show_ids=show_ids)
5215
annotate_file_tree(tree, file_id, self.outf, long, all,
5216
show_ids=show_ids, branch=branch)
4538
5217
4539
5218
4540
5219
class cmd_re_sign(Command):
4541
"""Create a digital signature for an existing revision."""
5220
__doc__ = """Create a digital signature for an existing revision."""
4542
5221
# TODO be able to replace existing ones.
4543
5222
4544
5223
hidden = True # is this right ?
4545
5224
takes_args = ['revision_id*']
4546
takes_options = ['revision']
5225
takes_options = ['directory', 'revision']
4547
5226
4548
def run(self, revision_id_list=None, revision=None):
5227
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4549
5228
if revision_id_list is not None and revision is not None:
4550
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
5229
raise errors.BzrCommandError(gettext('You can only supply one of revision_id or --revision'))
4551
5230
if revision_id_list is None and revision is None:
4552
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4553
b = WorkingTree.open_containing(u'.')[0].branch
4554
b.lock_write()
4555
self.add_cleanup(b.unlock)
5231
raise errors.BzrCommandError(gettext('You must supply either --revision or a revision_id'))
5232
b = WorkingTree.open_containing(directory)[0].branch
5233
self.add_cleanup(b.lock_write().unlock)
4556
5234
return self._run(b, revision_id_list, revision)
4557
5235
4558
5236
def _run(self, b, revision_id_list, revision):
4559
5237
import bzrlib.gpg as gpg
4560
gpg_strategy = gpg.GPGStrategy(b.get_config())
5238
gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4561
5239
if revision_id_list is not None:
4562
5240
b.repository.start_write_group()
4563
5241
try:
4588
5266
if to_revid is None:
4589
5267
to_revno = b.revno()
4590
5268
if from_revno is None or to_revno is None:
4591
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
5269
raise errors.BzrCommandError(gettext('Cannot sign a range of non-revision-history revisions'))
4592
5270
b.repository.start_write_group()
4593
5271
try:
4594
5272
for revno in range(from_revno, to_revno + 1):
4600
5278
else:
4601
5279
b.repository.commit_write_group()
4602
5280
else:
4603
raise errors.BzrCommandError('Please supply either one revision, or a range.')
5281
raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4604
5282
4605
5283
4606
5284
class cmd_bind(Command):
4607
"""Convert the current branch into a checkout of the supplied branch.
5285
__doc__ = """Convert the current branch into a checkout of the supplied branch.
5286
If no branch is supplied, rebind to the last bound location.
4608
5287
4609
5288
Once converted into a checkout, commits must succeed on the master branch
4610
5289
before they will be applied to the local branch.
4616
5295
4617
5296
_see_also = ['checkouts', 'unbind']
4618
5297
takes_args = ['location?']
4619
takes_options = []
5298
takes_options = ['directory']
4620
5299
4621
def run(self, location=None):
4622
b, relpath = Branch.open_containing(u'.')
5300
def run(self, location=None, directory=u'.'):
5301
b, relpath = Branch.open_containing(directory)
4623
5302
if location is None:
4624
5303
try:
4625
5304
location = b.get_old_bound_location()
4626
5305
except errors.UpgradeRequired:
4627
raise errors.BzrCommandError('No location supplied. '
4628
'This format does not remember old locations.')
5306
raise errors.BzrCommandError(gettext('No location supplied. '
5307
'This format does not remember old locations.'))
4629
5308
else:
4630
5309
if location is None:
4631
5310
if b.get_bound_location() is not None:
4632
raise errors.BzrCommandError('Branch is already bound')
5311
raise errors.BzrCommandError(
5312
gettext('Branch is already bound'))
4633
5313
else:
4634
raise errors.BzrCommandError('No location supplied '
4635
'and no previous location known')
5314
raise errors.BzrCommandError(
5315
gettext('No location supplied'
5316
' and no previous location known'))
4636
5317
b_other = Branch.open(location)
4637
5318
try:
4638
5319
b.bind(b_other)
4639
5320
except errors.DivergedBranches:
4640
raise errors.BzrCommandError('These branches have diverged.'
4641
' Try merging, and then bind again.')
5321
raise errors.BzrCommandError(gettext('These branches have diverged.'
5322
' Try merging, and then bind again.'))
4642
5323
if b.get_config().has_explicit_nickname():
4643
5324
b.nick = b_other.nick
4644
5325
4645
5326
4646
5327
class cmd_unbind(Command):
4647
"""Convert the current checkout into a regular branch.
5328
__doc__ = """Convert the current checkout into a regular branch.
4648
5329
4649
5330
After unbinding, the local branch is considered independent and subsequent
4650
5331
commits will be local only.
4652
5333
4653
5334
_see_also = ['checkouts', 'bind']
4654
5335
takes_args = []
4655
takes_options = []
5336
takes_options = ['directory']
4656
5337
4657
def run(self):
4658
b, relpath = Branch.open_containing(u'.')
5338
def run(self, directory=u'.'):
5339
b, relpath = Branch.open_containing(directory)
4659
5340
if not b.unbind():
4660
raise errors.BzrCommandError('Local branch is not bound')
5341
raise errors.BzrCommandError(gettext('Local branch is not bound'))
4661
5342
4662
5343
4663
5344
class cmd_uncommit(Command):
4664
"""Remove the last committed revision.
5345
__doc__ = """Remove the last committed revision.
4665
5346
4666
5347
--verbose will print out what is being removed.
4667
5348
--dry-run will go through all the motions, but not actually
4684
5365
takes_options = ['verbose', 'revision',
4685
5366
Option('dry-run', help='Don\'t actually make changes.'),
4686
5367
Option('force', help='Say yes to all questions.'),
5368
Option('keep-tags',
5369
help='Keep tags that point to removed revisions.'),
4687
5370
Option('local',
4688
5371
help="Only remove the commits from the local branch"
4689
5372
" when in a checkout."
4693
5376
aliases = []
4694
5377
encoding_type = 'replace'
4695
5378
4696
def run(self, location=None,
4697
dry_run=False, verbose=False,
4698
revision=None, force=False, local=False):
5379
def run(self, location=None, dry_run=False, verbose=False,
5380
revision=None, force=False, local=False, keep_tags=False):
4699
5381
if location is None:
4700
5382
location = u'.'
4701
control, relpath = bzrdir.BzrDir.open_containing(location)
5383
control, relpath = controldir.ControlDir.open_containing(location)
4702
5384
try:
4703
5385
tree = control.open_workingtree()
4704
5386
b = tree.branch
4707
5389
b = control.open_branch()
4708
5390
4709
5391
if tree is not None:
4710
tree.lock_write()
4711
self.add_cleanup(tree.unlock)
5392
self.add_cleanup(tree.lock_write().unlock)
4712
5393
else:
4713
b.lock_write()
4714
self.add_cleanup(b.unlock)
4715
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
5394
self.add_cleanup(b.lock_write().unlock)
5395
return self._run(b, tree, dry_run, verbose, revision, force,
5396
local, keep_tags)
4716
5397
4717
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
5398
def _run(self, b, tree, dry_run, verbose, revision, force, local,
5399
keep_tags):
4718
5400
from bzrlib.log import log_formatter, show_log
4719
5401
from bzrlib.uncommit import uncommit
4720
5402
4735
5417
rev_id = b.get_rev_id(revno)
4736
5418
4737
5419
if rev_id is None or _mod_revision.is_null(rev_id):
4738
self.outf.write('No revisions to uncommit.\n')
5420
self.outf.write(gettext('No revisions to uncommit.\n'))
4739
5421
return 1
4740
5422
4741
5423
lf = log_formatter('short',
4750
5432
end_revision=last_revno)
4751
5433
4752
5434
if dry_run:
4753
self.outf.write('Dry-run, pretending to remove'
4754
' the above revisions.\n')
5435
self.outf.write(gettext('Dry-run, pretending to remove'
5436
' the above revisions.\n'))
4755
5437
else:
4756
self.outf.write('The above revision(s) will be removed.\n')
5438
self.outf.write(gettext('The above revision(s) will be removed.\n'))
4757
5439
4758
5440
if not force:
4759
if not ui.ui_factory.get_boolean('Are you sure'):
4760
self.outf.write('Canceled')
5441
if not ui.ui_factory.confirm_action(
5442
gettext(u'Uncommit these revisions'),
5443
'bzrlib.builtins.uncommit',
5444
{}):
5445
self.outf.write(gettext('Canceled\n'))
4761
5446
return 0
4762
5447
4763
5448
mutter('Uncommitting from {%s} to {%s}',
4764
5449
last_rev_id, rev_id)
4765
5450
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4766
revno=revno, local=local)
4767
self.outf.write('You can restore the old tip by running:\n'
4768
' bzr pull . -r revid:%s\n' % last_rev_id)
5451
revno=revno, local=local, keep_tags=keep_tags)
5452
self.outf.write(gettext('You can restore the old tip by running:\n'
5453
' bzr pull . -r revid:%s\n') % last_rev_id)
4769
5454
4770
5455
4771
5456
class cmd_break_lock(Command):
4772
"""Break a dead lock on a repository, branch or working directory.
5457
__doc__ = """Break a dead lock.
5458
5459
This command breaks a lock on a repository, branch, working directory or
5460
config file.
4773
5461
4774
5462
CAUTION: Locks should only be broken when you are sure that the process
4775
5463
holding the lock has been stopped.
4780
5468
:Examples:
4781
5469
bzr break-lock
4782
5470
bzr break-lock bzr+ssh://example.com/bzr/foo
5471
bzr break-lock --conf ~/.bazaar
4783
5472
"""
5473
4784
5474
takes_args = ['location?']
5475
takes_options = [
5476
Option('config',
5477
help='LOCATION is the directory where the config lock is.'),
5478
Option('force',
5479
help='Do not ask for confirmation before breaking the lock.'),
5480
]
4785
5481
4786
def run(self, location=None, show=False):
5482
def run(self, location=None, config=False, force=False):
4787
5483
if location is None:
4788
5484
location = u'.'
4789
control, relpath = bzrdir.BzrDir.open_containing(location)
4790
try:
4791
control.break_lock()
4792
except NotImplementedError:
4793
pass
5485
if force:
5486
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
5487
None,
5488
{'bzrlib.lockdir.break': True})
5489
if config:
5490
conf = _mod_config.LockableConfig(file_name=location)
5491
conf.break_lock()
5492
else:
5493
control, relpath = controldir.ControlDir.open_containing(location)
5494
try:
5495
control.break_lock()
5496
except NotImplementedError:
5497
pass
4794
5498
4795
5499
4796
5500
class cmd_wait_until_signalled(Command):
4797
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
5501
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4798
5502
4799
5503
This just prints a line to signal when it is ready, then blocks on stdin.
4800
5504
"""
4808
5512
4809
5513
4810
5514
class cmd_serve(Command):
4811
"""Run the bzr server."""
5515
__doc__ = """Run the bzr server."""
4812
5516
4813
5517
aliases = ['server']
4814
5518
4819
5523
help="Protocol to serve.",
4820
5524
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4821
5525
value_switches=True),
5526
Option('listen',
5527
help='Listen for connections on nominated address.', type=str),
4822
5528
Option('port',
4823
help='Listen for connections on nominated port of the form '
4824
'[hostname:]portnumber. Passing 0 as the port number will '
4825
'result in a dynamically allocated port. The default port '
4826
'depends on the protocol.',
4827
type=str),
4828
Option('directory',
4829
help='Serve contents of this directory.',
4830
type=unicode),
5529
help='Listen for connections on nominated port. Passing 0 as '
5530
'the port number will result in a dynamically allocated '
5531
'port. The default port depends on the protocol.',
5532
type=int),
5533
custom_help('directory',
5534
help='Serve contents of this directory.'),
4831
5535
Option('allow-writes',
4832
5536
help='By default the server is a readonly server. Supplying '
4833
5537
'--allow-writes enables write access to the contents of '
4837
5541
'option leads to global uncontrolled write access to your '
4838
5542
'file system.'
4839
5543
),
5544
Option('client-timeout', type=float,
5545
help='Override the default idle client timeout (5min).'),
4840
5546
]
4841
5547
4842
def get_host_and_port(self, port):
4843
"""Return the host and port to run the smart server on.
4844
4845
If 'port' is None, None will be returned for the host and port.
4846
4847
If 'port' has a colon in it, the string before the colon will be
4848
interpreted as the host.
4849
4850
:param port: A string of the port to run the server on.
4851
:return: A tuple of (host, port), where 'host' is a host name or IP,
4852
and port is an integer TCP/IP port.
4853
"""
4854
host = None
4855
if port is not None:
4856
if ':' in port:
4857
host, port = port.split(':')
4858
port = int(port)
4859
return host, port
4860
4861
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4862
protocol=None):
4863
from bzrlib.transport import get_transport, transport_server_registry
5548
def run(self, listen=None, port=None, inet=False, directory=None,
5549
allow_writes=False, protocol=None, client_timeout=None):
5550
from bzrlib import transport
4864
5551
if directory is None:
4865
5552
directory = os.getcwd()
4866
5553
if protocol is None:
4867
protocol = transport_server_registry.get()
4868
host, port = self.get_host_and_port(port)
4869
url = urlutils.local_path_to_url(directory)
5554
protocol = transport.transport_server_registry.get()
5555
url = transport.location_to_url(directory)
4870
5556
if not allow_writes:
4871
5557
url = 'readonly+' + url
4872
transport = get_transport(url)
4873
protocol(transport, host, port, inet)
5558
t = transport.get_transport_from_url(url)
5559
protocol(t, listen, port, inet, client_timeout)
4874
5560
4875
5561
4876
5562
class cmd_join(Command):
4877
"""Combine a tree into its containing tree.
5563
__doc__ = """Combine a tree into its containing tree.
4878
5564
4879
5565
This command requires the target tree to be in a rich-root format.
4880
5566
4882
5568
not part of it. (Such trees can be produced by "bzr split", but also by
4883
5569
running "bzr branch" with the target inside a tree.)
4884
5570
4885
The result is a combined tree, with the subtree no longer an independant
5571
The result is a combined tree, with the subtree no longer an independent
4886
5572
part. This is marked as a merge of the subtree into the containing tree,
4887
5573
and all history is preserved.
4888
5574
"""
4899
5585
containing_tree = WorkingTree.open_containing(parent_dir)[0]
4900
5586
repo = containing_tree.branch.repository
4901
5587
if not repo.supports_rich_root():
4902
raise errors.BzrCommandError(
5588
raise errors.BzrCommandError(gettext(
4903
5589
"Can't join trees because %s doesn't support rich root data.\n"
4904
"You can use bzr upgrade on the repository."
5590
"You can use bzr upgrade on the repository.")
4905
5591
% (repo,))
4906
5592
if reference:
4907
5593
try:
4909
5595
except errors.BadReferenceTarget, e:
4910
5596
# XXX: Would be better to just raise a nicely printable
4911
5597
# exception from the real origin. Also below. mbp 20070306
4912
raise errors.BzrCommandError("Cannot join %s. %s" %
4913
(tree, e.reason))
5598
raise errors.BzrCommandError(
5599
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4914
5600
else:
4915
5601
try:
4916
5602
containing_tree.subsume(sub_tree)
4917
5603
except errors.BadSubsumeSource, e:
4918
raise errors.BzrCommandError("Cannot join %s. %s" %
4919
(tree, e.reason))
5604
raise errors.BzrCommandError(
5605
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4920
5606
4921
5607
4922
5608
class cmd_split(Command):
4923
"""Split a subdirectory of a tree into a separate tree.
5609
__doc__ = """Split a subdirectory of a tree into a separate tree.
4924
5610
4925
5611
This command will produce a target tree in a format that supports
4926
5612
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4946
5632
4947
5633
4948
5634
class cmd_merge_directive(Command):
4949
"""Generate a merge directive for auto-merge tools.
5635
__doc__ = """Generate a merge directive for auto-merge tools.
4950
5636
4951
5637
A directive requests a merge to be performed, and also provides all the
4952
5638
information necessary to do so. This means it must either include a
4969
5655
_see_also = ['send']
4970
5656
4971
5657
takes_options = [
5658
'directory',
4972
5659
RegistryOption.from_kwargs('patch-type',
4973
5660
'The type of patch to include in the directive.',
4974
5661
title='Patch type',
4987
5674
encoding_type = 'exact'
4988
5675
4989
5676
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4990
sign=False, revision=None, mail_to=None, message=None):
5677
sign=False, revision=None, mail_to=None, message=None,
5678
directory=u'.'):
4991
5679
from bzrlib.revision import ensure_null, NULL_REVISION
4992
5680
include_patch, include_bundle = {
4993
5681
'plain': (False, False),
4994
5682
'diff': (True, False),
4995
5683
'bundle': (True, True),
4996
5684
}[patch_type]
4997
branch = Branch.open('.')
5685
branch = Branch.open(directory)
4998
5686
stored_submit_branch = branch.get_submit_branch()
4999
5687
if submit_branch is None:
5000
5688
submit_branch = stored_submit_branch
5004
5692
if submit_branch is None:
5005
5693
submit_branch = branch.get_parent()
5006
5694
if submit_branch is None:
5007
raise errors.BzrCommandError('No submit branch specified or known')
5695
raise errors.BzrCommandError(gettext('No submit branch specified or known'))
5008
5696
5009
5697
stored_public_branch = branch.get_public_branch()
5010
5698
if public_branch is None:
5011
5699
public_branch = stored_public_branch
5012
5700
elif stored_public_branch is None:
5701
# FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5013
5702
branch.set_public_branch(public_branch)
5014
5703
if not include_bundle and public_branch is None:
5015
raise errors.BzrCommandError('No public branch specified or'
5016
' known')
5704
raise errors.BzrCommandError(gettext('No public branch specified or'
5705
' known'))
5017
5706
base_revision_id = None
5018
5707
if revision is not None:
5019
5708
if len(revision) > 2:
5020
raise errors.BzrCommandError('bzr merge-directive takes '
5021
'at most two one revision identifiers')
5709
raise errors.BzrCommandError(gettext('bzr merge-directive takes '
5710
'at most two one revision identifiers'))
5022
5711
revision_id = revision[-1].as_revision_id(branch)
5023
5712
if len(revision) == 2:
5024
5713
base_revision_id = revision[0].as_revision_id(branch)
5026
5715
revision_id = branch.last_revision()
5027
5716
revision_id = ensure_null(revision_id)
5028
5717
if revision_id == NULL_REVISION:
5029
raise errors.BzrCommandError('No revisions to bundle.')
5718
raise errors.BzrCommandError(gettext('No revisions to bundle.'))
5030
5719
directive = merge_directive.MergeDirective2.from_objects(
5031
5720
branch.repository, revision_id, time.time(),
5032
5721
osutils.local_time_offset(), submit_branch,
5040
5729
self.outf.writelines(directive.to_lines())
5041
5730
else:
5042
5731
message = directive.to_email(mail_to, branch, sign)
5043
s = SMTPConnection(branch.get_config())
5732
s = SMTPConnection(branch.get_config_stack())
5044
5733
s.send_email(message)
5045
5734
5046
5735
5047
5736
class cmd_send(Command):
5048
"""Mail or create a merge-directive for submitting changes.
5737
__doc__ = """Mail or create a merge-directive for submitting changes.
5049
5738
5050
5739
A merge directive provides many things needed for requesting merges:
5051
5740
5076
5765
source branch defaults to that containing the working directory, but can
5077
5766
be changed using --from.
5078
5767
5768
Both the submit branch and the public branch follow the usual behavior with
5769
respect to --remember: If there is no default location set, the first send
5770
will set it (use --no-remember to avoid setting it). After that, you can
5771
omit the location to use the default. To change the default, use
5772
--remember. The value will only be saved if the location can be accessed.
5773
5079
5774
In order to calculate those changes, bzr must analyse the submit branch.
5080
5775
Therefore it is most efficient for the submit branch to be a local mirror.
5081
5776
If a public location is known for the submit_branch, that location is used
5085
5780
given, in which case it is sent to a file.
5086
5781
5087
5782
Mail is sent using your preferred mail program. This should be transparent
5088
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5783
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5089
5784
If the preferred client can't be found (or used), your editor will be used.
5090
5785
5091
5786
To use a specific mail program, set the mail_client configuration option.
5133
5828
short_name='f',
5134
5829
type=unicode),
5135
5830
Option('output', short_name='o',
5136
help='Write merge directive to this file; '
5831
help='Write merge directive to this file or directory; '
5137
5832
'use - for stdout.',
5138
5833
type=unicode),
5139
5834
Option('strict',
5150
5845
]
5151
5846
5152
5847
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5153
no_patch=False, revision=None, remember=False, output=None,
5848
no_patch=False, revision=None, remember=None, output=None,
5154
5849
format=None, mail_to=None, message=None, body=None,
5155
5850
strict=None, **kwargs):
5156
5851
from bzrlib.send import send
5162
5857
5163
5858
5164
5859
class cmd_bundle_revisions(cmd_send):
5165
"""Create a merge-directive for submitting changes.
5860
__doc__ = """Create a merge-directive for submitting changes.
5166
5861
5167
5862
A merge directive provides many things needed for requesting merges:
5168
5863
5235
5930
5236
5931
5237
5932
class cmd_tag(Command):
5238
"""Create, remove or modify a tag naming a revision.
5933
__doc__ = """Create, remove or modify a tag naming a revision.
5239
5934
5240
5935
Tags give human-meaningful names to revisions. Commands that take a -r
5241
5936
(--revision) option can be given -rtag:X, where X is any previously
5249
5944
5250
5945
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5251
5946
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5947
5948
If no tag name is specified it will be determined through the
5949
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5950
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5951
details.
5252
5952
"""
5253
5953
5254
5954
_see_also = ['commit', 'tags']
5255
takes_args = ['tag_name']
5955
takes_args = ['tag_name?']
5256
5956
takes_options = [
5257
5957
Option('delete',
5258
5958
help='Delete this tag rather than placing it.',
5259
5959
),
5260
Option('directory',
5261
help='Branch in which to place the tag.',
5262
short_name='d',
5263
type=unicode,
5264
),
5960
custom_help('directory',
5961
help='Branch in which to place the tag.'),
5265
5962
Option('force',
5266
5963
help='Replace existing tags.',
5267
5964
),
5268
5965
'revision',
5269
5966
]
5270
5967
5271
def run(self, tag_name,
5968
def run(self, tag_name=None,
5272
5969
delete=None,
5273
5970
directory='.',
5274
5971
force=None,
5275
5972
revision=None,
5276
5973
):
5277
5974
branch, relpath = Branch.open_containing(directory)
5278
branch.lock_write()
5279
self.add_cleanup(branch.unlock)
5975
self.add_cleanup(branch.lock_write().unlock)
5280
5976
if delete:
5977
if tag_name is None:
5978
raise errors.BzrCommandError(gettext("No tag specified to delete."))
5281
5979
branch.tags.delete_tag(tag_name)
5282
self.outf.write('Deleted tag %s.\n' % tag_name)
5980
note(gettext('Deleted tag %s.') % tag_name)
5283
5981
else:
5284
5982
if revision:
5285
5983
if len(revision) != 1:
5286
raise errors.BzrCommandError(
5984
raise errors.BzrCommandError(gettext(
5287
5985
"Tags can only be placed on a single revision, "
5288
"not on a range")
5986
"not on a range"))
5289
5987
revision_id = revision[0].as_revision_id(branch)
5290
5988
else:
5291
5989
revision_id = branch.last_revision()
5292
if (not force) and branch.tags.has_tag(tag_name):
5990
if tag_name is None:
5991
tag_name = branch.automatic_tag_name(revision_id)
5992
if tag_name is None:
5993
raise errors.BzrCommandError(gettext(
5994
"Please specify a tag name."))
5995
try:
5996
existing_target = branch.tags.lookup_tag(tag_name)
5997
except errors.NoSuchTag:
5998
existing_target = None
5999
if not force and existing_target not in (None, revision_id):
5293
6000
raise errors.TagAlreadyExists(tag_name)
5294
branch.tags.set_tag(tag_name, revision_id)
5295
self.outf.write('Created tag %s.\n' % tag_name)
6001
if existing_target == revision_id:
6002
note(gettext('Tag %s already exists for that revision.') % tag_name)
6003
else:
6004
branch.tags.set_tag(tag_name, revision_id)
6005
if existing_target is None:
6006
note(gettext('Created tag %s.') % tag_name)
6007
else:
6008
note(gettext('Updated tag %s.') % tag_name)
5296
6009
5297
6010
5298
6011
class cmd_tags(Command):
5299
"""List tags.
6012
__doc__ = """List tags.
5300
6013
5301
6014
This command shows a table of tag names and the revisions they reference.
5302
6015
"""
5303
6016
5304
6017
_see_also = ['tag']
5305
6018
takes_options = [
5306
Option('directory',
5307
help='Branch whose tags should be displayed.',
5308
short_name='d',
5309
type=unicode,
5310
),
5311
RegistryOption.from_kwargs('sort',
6019
custom_help('directory',
6020
help='Branch whose tags should be displayed.'),
6021
RegistryOption('sort',
5312
6022
'Sort tags by different criteria.', title='Sorting',
5313
alpha='Sort tags lexicographically (default).',
5314
time='Sort tags chronologically.',
6023
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5315
6024
),
5316
6025
'show-ids',
5317
6026
'revision',
5318
6027
]
5319
6028
5320
6029
@display_command
5321
def run(self,
5322
directory='.',
5323
sort='alpha',
5324
show_ids=False,
5325
revision=None,
5326
):
6030
def run(self, directory='.', sort=None, show_ids=False, revision=None):
6031
from bzrlib.tag import tag_sort_methods
5327
6032
branch, relpath = Branch.open_containing(directory)
5328
6033
5329
6034
tags = branch.tags.get_tag_dict().items()
5330
6035
if not tags:
5331
6036
return
5332
6037
5333
branch.lock_read()
5334
self.add_cleanup(branch.unlock)
6038
self.add_cleanup(branch.lock_read().unlock)
5335
6039
if revision:
5336
graph = branch.repository.get_graph()
5337
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5338
revid1, revid2 = rev1.rev_id, rev2.rev_id
5339
# only show revisions between revid1 and revid2 (inclusive)
5340
tags = [(tag, revid) for tag, revid in tags if
5341
graph.is_between(revid, revid1, revid2)]
5342
if sort == 'alpha':
5343
tags.sort()
5344
elif sort == 'time':
5345
timestamps = {}
5346
for tag, revid in tags:
5347
try:
5348
revobj = branch.repository.get_revision(revid)
5349
except errors.NoSuchRevision:
5350
timestamp = sys.maxint # place them at the end
5351
else:
5352
timestamp = revobj.timestamp
5353
timestamps[revid] = timestamp
5354
tags.sort(key=lambda x: timestamps[x[1]])
6040
# Restrict to the specified range
6041
tags = self._tags_for_range(branch, revision)
6042
if sort is None:
6043
sort = tag_sort_methods.get()
6044
sort(branch, tags)
5355
6045
if not show_ids:
5356
6046
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5357
6047
for index, (tag, revid) in enumerate(tags):
5359
6049
revno = branch.revision_id_to_dotted_revno(revid)
5360
6050
if isinstance(revno, tuple):
5361
6051
revno = '.'.join(map(str, revno))
5362
except errors.NoSuchRevision:
6052
except (errors.NoSuchRevision,
6053
errors.GhostRevisionsHaveNoRevno,
6054
errors.UnsupportedOperation):
5363
6055
# Bad tag data/merges can lead to tagged revisions
5364
6056
# which are not in this branch. Fail gracefully ...
5365
6057
revno = '?'
5368
6060
for tag, revspec in tags:
5369
6061
self.outf.write('%-20s %s\n' % (tag, revspec))
5370
6062
6063
def _tags_for_range(self, branch, revision):
6064
range_valid = True
6065
rev1, rev2 = _get_revision_range(revision, branch, self.name())
6066
revid1, revid2 = rev1.rev_id, rev2.rev_id
6067
# _get_revision_range will always set revid2 if it's not specified.
6068
# If revid1 is None, it means we want to start from the branch
6069
# origin which is always a valid ancestor. If revid1 == revid2, the
6070
# ancestry check is useless.
6071
if revid1 and revid1 != revid2:
6072
# FIXME: We really want to use the same graph than
6073
# branch.iter_merge_sorted_revisions below, but this is not
6074
# easily available -- vila 2011-09-23
6075
if branch.repository.get_graph().is_ancestor(revid2, revid1):
6076
# We don't want to output anything in this case...
6077
return []
6078
# only show revisions between revid1 and revid2 (inclusive)
6079
tagged_revids = branch.tags.get_reverse_tag_dict()
6080
found = []
6081
for r in branch.iter_merge_sorted_revisions(
6082
start_revision_id=revid2, stop_revision_id=revid1,
6083
stop_rule='include'):
6084
revid_tags = tagged_revids.get(r[0], None)
6085
if revid_tags:
6086
found.extend([(tag, r[0]) for tag in revid_tags])
6087
return found
6088
5371
6089
5372
6090
class cmd_reconfigure(Command):
5373
"""Reconfigure the type of a bzr directory.
6091
__doc__ = """Reconfigure the type of a bzr directory.
5374
6092
5375
6093
A target configuration must be specified.
5376
6094
5387
6105
takes_args = ['location?']
5388
6106
takes_options = [
5389
6107
RegistryOption.from_kwargs(
5390
'target_type',
5391
title='Target type',
5392
help='The type to reconfigure the directory to.',
6108
'tree_type',
6109
title='Tree type',
6110
help='The relation between branch and tree.',
5393
6111
value_switches=True, enum_switch=False,
5394
6112
branch='Reconfigure to be an unbound branch with no working tree.',
5395
6113
tree='Reconfigure to be an unbound branch with a working tree.',
5396
6114
checkout='Reconfigure to be a bound branch with a working tree.',
5397
6115
lightweight_checkout='Reconfigure to be a lightweight'
5398
6116
' checkout (with no local history).',
6117
),
6118
RegistryOption.from_kwargs(
6119
'repository_type',
6120
title='Repository type',
6121
help='Location fo the repository.',
6122
value_switches=True, enum_switch=False,
5399
6123
standalone='Reconfigure to be a standalone branch '
5400
6124
'(i.e. stop using shared repository).',
5401
6125
use_shared='Reconfigure to use a shared repository.',
6126
),
6127
RegistryOption.from_kwargs(
6128
'repository_trees',
6129
title='Trees in Repository',
6130
help='Whether new branches in the repository have trees.',
6131
value_switches=True, enum_switch=False,
5402
6132
with_trees='Reconfigure repository to create '
5403
6133
'working trees on branches by default.',
5404
6134
with_no_trees='Reconfigure repository to not create '
5418
6148
),
5419
6149
]
5420
6150
5421
def run(self, location=None, target_type=None, bind_to=None, force=False,
5422
stacked_on=None,
5423
unstacked=None):
5424
directory = bzrdir.BzrDir.open(location)
6151
def run(self, location=None, bind_to=None, force=False,
6152
tree_type=None, repository_type=None, repository_trees=None,
6153
stacked_on=None, unstacked=None):
6154
directory = controldir.ControlDir.open(location)
5425
6155
if stacked_on and unstacked:
5426
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
6156
raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5427
6157
elif stacked_on is not None:
5428
6158
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5429
6159
elif unstacked:
5431
6161
# At the moment you can use --stacked-on and a different
5432
6162
# reconfiguration shape at the same time; there seems no good reason
5433
6163
# to ban it.
5434
if target_type is None:
6164
if (tree_type is None and
6165
repository_type is None and
6166
repository_trees is None):
5435
6167
if stacked_on or unstacked:
5436
6168
return
5437
6169
else:
5438
raise errors.BzrCommandError('No target configuration '
5439
'specified')
5440
elif target_type == 'branch':
6170
raise errors.BzrCommandError(gettext('No target configuration '
6171
'specified'))
6172
reconfiguration = None
6173
if tree_type == 'branch':
5441
6174
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5442
elif target_type == 'tree':
6175
elif tree_type == 'tree':
5443
6176
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5444
elif target_type == 'checkout':
6177
elif tree_type == 'checkout':
5445
6178
reconfiguration = reconfigure.Reconfigure.to_checkout(
5446
6179
directory, bind_to)
5447
elif target_type == 'lightweight-checkout':
6180
elif tree_type == 'lightweight-checkout':
5448
6181
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5449
6182
directory, bind_to)
5450
elif target_type == 'use-shared':
6183
if reconfiguration:
6184
reconfiguration.apply(force)
6185
reconfiguration = None
6186
if repository_type == 'use-shared':
5451
6187
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5452
elif target_type == 'standalone':
6188
elif repository_type == 'standalone':
5453
6189
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5454
elif target_type == 'with-trees':
6190
if reconfiguration:
6191
reconfiguration.apply(force)
6192
reconfiguration = None
6193
if repository_trees == 'with-trees':
5455
6194
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5456
6195
directory, True)
5457
elif target_type == 'with-no-trees':
6196
elif repository_trees == 'with-no-trees':
5458
6197
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5459
6198
directory, False)
5460
reconfiguration.apply(force)
6199
if reconfiguration:
6200
reconfiguration.apply(force)
6201
reconfiguration = None
5461
6202
5462
6203
5463
6204
class cmd_switch(Command):
5464
"""Set the branch of a checkout and update.
6205
__doc__ = """Set the branch of a checkout and update.
5465
6206
5466
6207
For lightweight checkouts, this changes the branch being referenced.
5467
6208
For heavyweight checkouts, this checks that there are no local commits
5484
6225
"""
5485
6226
5486
6227
takes_args = ['to_location?']
5487
takes_options = [Option('force',
6228
takes_options = ['directory',
6229
Option('force',
5488
6230
help='Switch even if local commits will be lost.'),
5489
6231
'revision',
5490
6232
Option('create-branch', short_name='b',
5491
6233
help='Create the target branch from this one before'
5492
6234
' switching to it.'),
6235
Option('store',
6236
help='Store and restore uncommitted changes in the'
6237
' branch.'),
5493
6238
]
5494
6239
5495
6240
def run(self, to_location=None, force=False, create_branch=False,
5496
revision=None):
6241
revision=None, directory=u'.', store=False):
5497
6242
from bzrlib import switch
5498
tree_location = '.'
6243
tree_location = directory
5499
6244
revision = _get_one_revision('switch', revision)
5500
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
6245
possible_transports = []
6246
control_dir = controldir.ControlDir.open_containing(tree_location,
6247
possible_transports=possible_transports)[0]
5501
6248
if to_location is None:
5502
6249
if revision is None:
5503
raise errors.BzrCommandError('You must supply either a'
5504
' revision or a location')
5505
to_location = '.'
6250
raise errors.BzrCommandError(gettext('You must supply either a'
6251
' revision or a location'))
6252
to_location = tree_location
5506
6253
try:
5507
branch = control_dir.open_branch()
6254
branch = control_dir.open_branch(
6255
possible_transports=possible_transports)
5508
6256
had_explicit_nick = branch.get_config().has_explicit_nickname()
5509
6257
except errors.NotBranchError:
5510
6258
branch = None
5511
6259
had_explicit_nick = False
5512
6260
if create_branch:
5513
6261
if branch is None:
5514
raise errors.BzrCommandError('cannot create branch without'
5515
' source branch')
5516
to_location = directory_service.directories.dereference(
5517
to_location)
5518
if '/' not in to_location and '\\' not in to_location:
5519
# This path is meant to be relative to the existing branch
5520
this_url = self._get_branch_location(control_dir)
5521
to_location = urlutils.join(this_url, '..', to_location)
6262
raise errors.BzrCommandError(
6263
gettext('cannot create branch without source branch'))
6264
to_location = lookup_new_sibling_branch(control_dir, to_location,
6265
possible_transports=possible_transports)
5522
6266
to_branch = branch.bzrdir.sprout(to_location,
5523
possible_transports=[branch.bzrdir.root_transport],
5524
source_branch=branch).open_branch()
6267
possible_transports=possible_transports,
6268
source_branch=branch).open_branch()
5525
6269
else:
5526
6270
try:
5527
to_branch = Branch.open(to_location)
6271
to_branch = Branch.open(to_location,
6272
possible_transports=possible_transports)
5528
6273
except errors.NotBranchError:
5529
this_url = self._get_branch_location(control_dir)
5530
to_branch = Branch.open(
5531
urlutils.join(this_url, '..', to_location))
6274
to_branch = open_sibling_branch(control_dir, to_location,
6275
possible_transports=possible_transports)
5532
6276
if revision is not None:
5533
6277
revision = revision.as_revision_id(to_branch)
5534
switch.switch(control_dir, to_branch, force, revision_id=revision)
6278
switch.switch(control_dir, to_branch, force, revision_id=revision,
6279
store_uncommitted=store)
5535
6280
if had_explicit_nick:
5536
6281
branch = control_dir.open_branch() #get the new branch!
5537
6282
branch.nick = to_branch.nick
5538
note('Switched to branch: %s',
6283
note(gettext('Switched to branch: %s'),
5539
6284
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5540
6285
5541
def _get_branch_location(self, control_dir):
5542
"""Return location of branch for this control dir."""
5543
try:
5544
this_branch = control_dir.open_branch()
5545
# This may be a heavy checkout, where we want the master branch
5546
master_location = this_branch.get_bound_location()
5547
if master_location is not None:
5548
return master_location
5549
# If not, use a local sibling
5550
return this_branch.base
5551
except errors.NotBranchError:
5552
format = control_dir.find_branch_format()
5553
if getattr(format, 'get_reference', None) is not None:
5554
return format.get_reference(control_dir)
5555
else:
5556
return control_dir.root_transport.base
5557
6286
5558
6287
5559
6288
class cmd_view(Command):
5560
"""Manage filtered views.
6289
__doc__ = """Manage filtered views.
5561
6290
5562
6291
Views provide a mask over the tree so that users can focus on
5563
6292
a subset of a tree when doing their work. After creating a view,
5643
6372
name=None,
5644
6373
switch=None,
5645
6374
):
5646
tree, file_list = tree_files(file_list, apply_view=False)
6375
tree, file_list = WorkingTree.open_containing_paths(file_list,
6376
apply_view=False)
5647
6377
current_view, view_dict = tree.views.get_view_info()
5648
6378
if name is None:
5649
6379
name = current_view
5650
6380
if delete:
5651
6381
if file_list:
5652
raise errors.BzrCommandError(
5653
"Both --delete and a file list specified")
6382
raise errors.BzrCommandError(gettext(
6383
"Both --delete and a file list specified"))
5654
6384
elif switch:
5655
raise errors.BzrCommandError(
5656
"Both --delete and --switch specified")
6385
raise errors.BzrCommandError(gettext(
6386
"Both --delete and --switch specified"))
5657
6387
elif all:
5658
6388
tree.views.set_view_info(None, {})
5659
self.outf.write("Deleted all views.\n")
6389
self.outf.write(gettext("Deleted all views.\n"))
5660
6390
elif name is None:
5661
raise errors.BzrCommandError("No current view to delete")
6391
raise errors.BzrCommandError(gettext("No current view to delete"))
5662
6392
else:
5663
6393
tree.views.delete_view(name)
5664
self.outf.write("Deleted '%s' view.\n" % name)
6394
self.outf.write(gettext("Deleted '%s' view.\n") % name)
5665
6395
elif switch:
5666
6396
if file_list:
5667
raise errors.BzrCommandError(
5668
"Both --switch and a file list specified")
6397
raise errors.BzrCommandError(gettext(
6398
"Both --switch and a file list specified"))
5669
6399
elif all:
5670
raise errors.BzrCommandError(
5671
"Both --switch and --all specified")
6400
raise errors.BzrCommandError(gettext(
6401
"Both --switch and --all specified"))
5672
6402
elif switch == 'off':
5673
6403
if current_view is None:
5674
raise errors.BzrCommandError("No current view to disable")
6404
raise errors.BzrCommandError(gettext("No current view to disable"))
5675
6405
tree.views.set_view_info(None, view_dict)
5676
self.outf.write("Disabled '%s' view.\n" % (current_view))
6406
self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5677
6407
else:
5678
6408
tree.views.set_view_info(switch, view_dict)
5679
6409
view_str = views.view_display_str(tree.views.lookup_view())
5680
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
6410
self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
5681
6411
elif all:
5682
6412
if view_dict:
5683
self.outf.write('Views defined:\n')
6413
self.outf.write(gettext('Views defined:\n'))
5684
6414
for view in sorted(view_dict):
5685
6415
if view == current_view:
5686
6416
active = "=>"
5689
6419
view_str = views.view_display_str(view_dict[view])
5690
6420
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5691
6421
else:
5692
self.outf.write('No views defined.\n')
6422
self.outf.write(gettext('No views defined.\n'))
5693
6423
elif file_list:
5694
6424
if name is None:
5695
6425
# No name given and no current view set
5696
6426
name = 'my'
5697
6427
elif name == 'off':
5698
raise errors.BzrCommandError(
5699
"Cannot change the 'off' pseudo view")
6428
raise errors.BzrCommandError(gettext(
6429
"Cannot change the 'off' pseudo view"))
5700
6430
tree.views.set_view(name, sorted(file_list))
5701
6431
view_str = views.view_display_str(tree.views.lookup_view())
5702
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
6432
self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
5703
6433
else:
5704
6434
# list the files
5705
6435
if name is None:
5706
6436
# No name given and no current view set
5707
self.outf.write('No current view.\n')
6437
self.outf.write(gettext('No current view.\n'))
5708
6438
else:
5709
6439
view_str = views.view_display_str(tree.views.lookup_view(name))
5710
self.outf.write("'%s' view is: %s\n" % (name, view_str))
6440
self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
5711
6441
5712
6442
5713
6443
class cmd_hooks(Command):
5714
"""Show hooks."""
6444
__doc__ = """Show hooks."""
5715
6445
5716
6446
hidden = True
5717
6447
5727
6457
self.outf.write(" %s\n" %
5728
6458
(some_hooks.get_hook_name(hook),))
5729
6459
else:
5730
self.outf.write(" <no hooks installed>\n")
6460
self.outf.write(gettext(" <no hooks installed>\n"))
6461
6462
6463
class cmd_remove_branch(Command):
6464
__doc__ = """Remove a branch.
6465
6466
This will remove the branch from the specified location but
6467
will keep any working tree or repository in place.
6468
6469
:Examples:
6470
6471
Remove the branch at repo/trunk::
6472
6473
bzr remove-branch repo/trunk
6474
6475
"""
6476
6477
takes_args = ["location?"]
6478
6479
takes_options = ['directory',
6480
Option('force', help='Remove branch even if it is the active branch.')]
6481
6482
aliases = ["rmbranch"]
6483
6484
def run(self, directory=None, location=None, force=False):
6485
br = open_nearby_branch(near=directory, location=location)
6486
if not force and br.bzrdir.has_workingtree():
6487
try:
6488
active_branch = br.bzrdir.open_branch(name="")
6489
except errors.NotBranchError:
6490
active_branch = None
6491
if (active_branch is not None and
6492
br.control_url == active_branch.control_url):
6493
raise errors.BzrCommandError(
6494
gettext("Branch is active. Use --force to remove it."))
6495
br.bzrdir.destroy_branch(br.name)
5731
6496
5732
6497
5733
6498
class cmd_shelve(Command):
5734
"""Temporarily set aside some changes from the current tree.
6499
__doc__ = """Temporarily set aside some changes from the current tree.
5735
6500
5736
6501
Shelve allows you to temporarily put changes you've made "on the shelf",
5737
6502
ie. out of the way, until a later time when you can bring them back from
5753
6518
5754
6519
You can put multiple items on the shelf, and by default, 'unshelve' will
5755
6520
restore the most recently shelved changes.
6521
6522
For complicated changes, it is possible to edit the changes in a separate
6523
editor program to decide what the file remaining in the working copy
6524
should look like. To do this, add the configuration option
6525
6526
change_editor = PROGRAM @new_path @old_path
6527
6528
where @new_path is replaced with the path of the new version of the
6529
file and @old_path is replaced with the path of the old version of
6530
the file. The PROGRAM should save the new file with the desired
6531
contents of the file in the working tree.
6532
5756
6533
"""
5757
6534
5758
6535
takes_args = ['file*']
5759
6536
5760
6537
takes_options = [
6538
'directory',
5761
6539
'revision',
5762
6540
Option('all', help='Shelve all changes.'),
5763
6541
'message',
5769
6547
Option('destroy',
5770
6548
help='Destroy removed changes instead of shelving them.'),
5771
6549
]
5772
_see_also = ['unshelve']
6550
_see_also = ['unshelve', 'configuration']
5773
6551
5774
6552
def run(self, revision=None, all=False, file_list=None, message=None,
5775
writer=None, list=False, destroy=False):
6553
writer=None, list=False, destroy=False, directory=None):
5776
6554
if list:
5777
return self.run_for_list()
6555
return self.run_for_list(directory=directory)
5778
6556
from bzrlib.shelf_ui import Shelver
5779
6557
if writer is None:
5780
6558
writer = bzrlib.option.diff_writer_registry.get()
5781
6559
try:
5782
6560
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5783
file_list, message, destroy=destroy)
6561
file_list, message, destroy=destroy, directory=directory)
5784
6562
try:
5785
6563
shelver.run()
5786
6564
finally:
5788
6566
except errors.UserAbort:
5789
6567
return 0
5790
6568
5791
def run_for_list(self):
5792
tree = WorkingTree.open_containing('.')[0]
5793
tree.lock_read()
5794
self.add_cleanup(tree.unlock)
6569
def run_for_list(self, directory=None):
6570
if directory is None:
6571
directory = u'.'
6572
tree = WorkingTree.open_containing(directory)[0]
6573
self.add_cleanup(tree.lock_read().unlock)
5795
6574
manager = tree.get_shelf_manager()
5796
6575
shelves = manager.active_shelves()
5797
6576
if len(shelves) == 0:
5798
note('No shelved changes.')
6577
note(gettext('No shelved changes.'))
5799
6578
return 0
5800
6579
for shelf_id in reversed(shelves):
5801
6580
message = manager.get_metadata(shelf_id).get('message')
5806
6585
5807
6586
5808
6587
class cmd_unshelve(Command):
5809
"""Restore shelved changes.
6588
__doc__ = """Restore shelved changes.
5810
6589
5811
6590
By default, the most recently shelved changes are restored. However if you
5812
6591
specify a shelf by id those changes will be restored instead. This works
5815
6594
5816
6595
takes_args = ['shelf_id?']
5817
6596
takes_options = [
6597
'directory',
5818
6598
RegistryOption.from_kwargs(
5819
6599
'action', help="The action to perform.",
5820
6600
enum_switch=False, value_switches=True,
5828
6608
]
5829
6609
_see_also = ['shelve']
5830
6610
5831
def run(self, shelf_id=None, action='apply'):
6611
def run(self, shelf_id=None, action='apply', directory=u'.'):
5832
6612
from bzrlib.shelf_ui import Unshelver
5833
unshelver = Unshelver.from_args(shelf_id, action)
6613
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5834
6614
try:
5835
6615
unshelver.run()
5836
6616
finally:
5838
6618
5839
6619
5840
6620
class cmd_clean_tree(Command):
5841
"""Remove unwanted files from working tree.
6621
__doc__ = """Remove unwanted files from working tree.
5842
6622
5843
6623
By default, only unknown files, not ignored files, are deleted. Versioned
5844
6624
files are never deleted.
5852
6632
5853
6633
To check what clean-tree will do, use --dry-run.
5854
6634
"""
5855
takes_options = [Option('ignored', help='Delete all ignored files.'),
5856
Option('detritus', help='Delete conflict files, merge'
6635
takes_options = ['directory',
6636
Option('ignored', help='Delete all ignored files.'),
6637
Option('detritus', help='Delete conflict files, merge and revert'
5857
6638
' backups, and failed selftest dirs.'),
5858
6639
Option('unknown',
5859
6640
help='Delete files unknown to bzr (default).'),
5861
6642
' deleting them.'),
5862
6643
Option('force', help='Do not prompt before deleting.')]
5863
6644
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5864
force=False):
6645
force=False, directory=u'.'):
5865
6646
from bzrlib.clean_tree import clean_tree
5866
6647
if not (unknown or ignored or detritus):
5867
6648
unknown = True
5868
6649
if dry_run:
5869
6650
force = True
5870
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5871
dry_run=dry_run, no_prompt=force)
6651
clean_tree(directory, unknown=unknown, ignored=ignored,
6652
detritus=detritus, dry_run=dry_run, no_prompt=force)
5872
6653
5873
6654
5874
6655
class cmd_reference(Command):
5875
"""list, view and set branch locations for nested trees.
6656
__doc__ = """list, view and set branch locations for nested trees.
5876
6657
5877
6658
If no arguments are provided, lists the branch locations for nested trees.
5878
6659
If one argument is provided, display the branch location for that tree.
5888
6669
if path is not None:
5889
6670
branchdir = path
5890
6671
tree, branch, relpath =(
5891
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
6672
controldir.ControlDir.open_containing_tree_or_branch(branchdir))
5892
6673
if path is not None:
5893
6674
path = relpath
5894
6675
if tree is None:
5918
6699
self.outf.write('%s %s\n' % (path, location))
5919
6700
5920
6701
5921
# these get imported and then picked up by the scan for cmd_*
5922
# TODO: Some more consistent way to split command definitions across files;
5923
# we do need to load at least some information about them to know of
5924
# aliases. ideally we would avoid loading the implementation until the
5925
# details were needed.
5926
from bzrlib.cmd_version_info import cmd_version_info
5927
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5928
from bzrlib.bundle.commands import (
5929
cmd_bundle_info,
5930
)
5931
from bzrlib.foreign import cmd_dpush
5932
from bzrlib.sign_my_commits import cmd_sign_my_commits
6702
class cmd_export_pot(Command):
6703
__doc__ = """Export command helps and error messages in po format."""
6704
6705
hidden = True
6706
takes_options = [Option('plugin',
6707
help='Export help text from named command '\
6708
'(defaults to all built in commands).',
6709
type=str),
6710
Option('include-duplicates',
6711
help='Output multiple copies of the same msgid '
6712
'string if it appears more than once.'),
6713
]
6714
6715
def run(self, plugin=None, include_duplicates=False):
6716
from bzrlib.export_pot import export_pot
6717
export_pot(self.outf, plugin, include_duplicates)
6718
6719
6720
def _register_lazy_builtins():
6721
# register lazy builtins from other modules; called at startup and should
6722
# be only called once.
6723
for (name, aliases, module_name) in [
6724
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6725
('cmd_config', [], 'bzrlib.config'),
6726
('cmd_dpush', [], 'bzrlib.foreign'),
6727
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6728
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6729
('cmd_conflicts', [], 'bzrlib.conflicts'),
6730
('cmd_ping', [], 'bzrlib.smart.ping'),
6731
('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6732
('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
6733
('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6734
]:
6735
builtin_command_registry.register_lazy(name, aliases, module_name)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1