« 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:
- .testr.conf
- apport
- 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
- doc/en/whats-new
- po
- files removed:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- files renamed:
- 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) 2004-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
61
from bzrlib.transport import memory
57
62
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
58
63
from bzrlib.smtp_connection import SMTPConnection
59
64
from bzrlib.workingtree import WorkingTree
65
from bzrlib.i18n import gettext, ngettext
60
66
""")
61
67
62
from bzrlib.commands import Command, display_command
68
from bzrlib.commands import (
69
Command,
70
builtin_command_registry,
71
display_command,
72
)
63
73
from bzrlib.option import (
64
74
ListOption,
65
75
Option,
68
78
_parse_revision_str,
69
79
)
70
80
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
71
72
73
def tree_files(file_list, default_branch=u'.', canonicalize=True,
74
apply_view=True):
75
try:
76
return internal_tree_files(file_list, default_branch, canonicalize,
77
apply_view)
78
except errors.FileInWrongBranch, e:
79
raise errors.BzrCommandError("%s is not in the same branch as %s" %
80
(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
81
221
82
222
83
223
def tree_files_for_add(file_list):
108
248
if view_files:
109
249
file_list = view_files
110
250
view_str = views.view_display_str(view_files)
111
note("Ignoring files outside view. View is %s" % view_str)
251
note(gettext("Ignoring files outside view. View is %s") % view_str)
112
252
return tree, file_list
113
253
114
254
116
256
if revisions is None:
117
257
return None
118
258
if len(revisions) != 1:
119
raise errors.BzrCommandError(
120
'bzr %s --revision takes exactly one revision identifier' % (
259
raise errors.BzrCommandError(gettext(
260
'bzr %s --revision takes exactly one revision identifier') % (
121
261
command_name,))
122
262
return revisions[0]
123
263
145
285
return rev_tree
146
286
147
287
148
# XXX: Bad function name; should possibly also be a class method of
149
# WorkingTree rather than a function.
150
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
151
apply_view=True):
152
"""Convert command-line paths to a WorkingTree and relative paths.
153
154
This is typically used for command-line processors that take one or
155
more filenames, and infer the workingtree that contains them.
156
157
The filenames given are not required to exist.
158
159
:param file_list: Filenames to convert.
160
161
:param default_branch: Fallback tree path to use if file_list is empty or
162
None.
163
164
:param apply_view: if True and a view is set, apply it or check that
165
specified files are within it
166
167
:return: workingtree, [relative_paths]
168
"""
169
if file_list is None or len(file_list) == 0:
170
tree = WorkingTree.open_containing(default_branch)[0]
171
if tree.supports_views() and apply_view:
172
view_files = tree.views.lookup_view()
173
if view_files:
174
file_list = view_files
175
view_str = views.view_display_str(view_files)
176
note("Ignoring files outside view. View is %s" % view_str)
177
return tree, file_list
178
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
179
return tree, safe_relpath_files(tree, file_list, canonicalize,
180
apply_view=apply_view)
181
182
183
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
184
"""Convert file_list into a list of relpaths in tree.
185
186
:param tree: A tree to operate on.
187
:param file_list: A list of user provided paths or None.
188
:param apply_view: if True and a view is set, apply it or check that
189
specified files are within it
190
:return: A list of relative paths.
191
:raises errors.PathNotChild: When a provided path is in a different tree
192
than tree.
193
"""
194
if file_list is None:
195
return None
196
if tree.supports_views() and apply_view:
197
view_files = tree.views.lookup_view()
198
else:
199
view_files = []
200
new_list = []
201
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
202
# doesn't - fix that up here before we enter the loop.
203
if canonicalize:
204
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
205
else:
206
fixer = tree.relpath
207
for filename in file_list:
208
try:
209
relpath = fixer(osutils.dereference_path(filename))
210
if view_files and not osutils.is_inside_any(view_files, relpath):
211
raise errors.FileOutsideView(filename, view_files)
212
new_list.append(relpath)
213
except errors.PathNotChild:
214
raise errors.FileInWrongBranch(tree.branch, filename)
215
return new_list
216
217
218
288
def _get_view_info_for_change_reporter(tree):
219
289
"""Get the view information from a tree for change reporting."""
220
290
view_info = None
227
297
return view_info
228
298
229
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
230
308
# TODO: Make sure no commands unconditionally use the working directory as a
231
309
# branch. If a filename argument is used, the first of them should be used to
232
310
# specify the branch. (Perhaps this can be factored out into some kind of
234
312
# opens the branch?)
235
313
236
314
class cmd_status(Command):
237
"""Display status summary.
315
__doc__ = """Display status summary.
238
316
239
317
This reports on versioned and unknown files, reporting them
240
318
grouped by state. Possible states are:
260
338
unknown
261
339
Not versioned and not matching an ignore pattern.
262
340
263
Additionally for directories, symlinks and files with an executable
264
bit, Bazaar indicates their type using a trailing character: '/', '@'
265
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.
266
345
267
346
To see ignored files use 'bzr ignored'. For details on the
268
347
changes to file texts, use 'bzr diff'.
281
360
To skip the display of pending merge information altogether, use
282
361
the no-pending option or specify a file/directory.
283
362
284
If a revision argument is given, the status is calculated against
285
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'.
286
369
"""
287
370
288
# TODO: --no-recurse, --recurse options
371
# TODO: --no-recurse/-N, --recurse options
289
372
290
373
takes_args = ['file*']
291
374
takes_options = ['show-ids', 'revision', 'change', 'verbose',
295
378
short_name='V'),
296
379
Option('no-pending', help='Don\'t show pending merges.',
297
380
),
381
Option('no-classify',
382
help='Do not mark object type using indicator.',
383
),
298
384
]
299
385
aliases = ['st', 'stat']
300
386
303
389
304
390
@display_command
305
391
def run(self, show_ids=False, file_list=None, revision=None, short=False,
306
versioned=False, no_pending=False, verbose=False):
392
versioned=False, no_pending=False, verbose=False,
393
no_classify=False):
307
394
from bzrlib.status import show_tree_status
308
395
309
396
if revision and len(revision) > 2:
310
raise errors.BzrCommandError('bzr status --revision takes exactly'
311
' one or two revision specifiers')
397
raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
398
' one or two revision specifiers'))
312
399
313
tree, relfile_list = tree_files(file_list)
400
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
314
401
# Avoid asking for specific files when that is not needed.
315
402
if relfile_list == ['']:
316
403
relfile_list = None
323
410
show_tree_status(tree, show_ids=show_ids,
324
411
specific_files=relfile_list, revision=revision,
325
412
to_file=self.outf, short=short, versioned=versioned,
326
show_pending=(not no_pending), verbose=verbose)
413
show_pending=(not no_pending), verbose=verbose,
414
classify=not no_classify)
327
415
328
416
329
417
class cmd_cat_revision(Command):
330
"""Write out metadata for a revision.
418
__doc__ = """Write out metadata for a revision.
331
419
332
420
The revision to print can either be specified by a specific
333
421
revision identifier, or you can use --revision.
335
423
336
424
hidden = True
337
425
takes_args = ['revision_id?']
338
takes_options = ['revision']
426
takes_options = ['directory', 'revision']
339
427
# cat-revision is more for frontends so should be exact
340
428
encoding = 'strict'
341
429
430
def print_revision(self, revisions, revid):
431
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
432
record = stream.next()
433
if record.storage_kind == 'absent':
434
raise errors.NoSuchRevision(revisions, revid)
435
revtext = record.get_bytes_as('fulltext')
436
self.outf.write(revtext.decode('utf-8'))
437
342
438
@display_command
343
def run(self, revision_id=None, revision=None):
439
def run(self, revision_id=None, revision=None, directory=u'.'):
344
440
if revision_id is not None and revision is not None:
345
raise errors.BzrCommandError('You can only supply one of'
346
' revision_id or --revision')
441
raise errors.BzrCommandError(gettext('You can only supply one of'
442
' revision_id or --revision'))
347
443
if revision_id is None and revision is None:
348
raise errors.BzrCommandError('You must supply either'
349
' --revision or a revision_id')
350
b = WorkingTree.open_containing(u'.')[0].branch
351
352
# TODO: jam 20060112 should cat-revision always output utf-8?
353
if revision_id is not None:
354
revision_id = osutils.safe_revision_id(revision_id, warn=False)
355
try:
356
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
357
except errors.NoSuchRevision:
358
msg = "The repository %s contains no revision %s." % (b.repository.base,
359
revision_id)
360
raise errors.BzrCommandError(msg)
361
elif revision is not None:
362
for rev in revision:
363
if rev is None:
364
raise errors.BzrCommandError('You cannot specify a NULL'
365
' revision.')
366
rev_id = rev.as_revision_id(b)
367
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
368
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]
448
449
revisions = b.repository.revisions
450
if revisions is None:
451
raise errors.BzrCommandError(gettext('Repository %r does not support '
452
'access to raw revision texts'))
453
454
b.repository.lock_read()
455
try:
456
# TODO: jam 20060112 should cat-revision always output utf-8?
457
if revision_id is not None:
458
revision_id = osutils.safe_revision_id(revision_id, warn=False)
459
try:
460
self.print_revision(revisions, revision_id)
461
except errors.NoSuchRevision:
462
msg = gettext("The repository {0} contains no revision {1}.").format(
463
b.repository.base, revision_id)
464
raise errors.BzrCommandError(msg)
465
elif revision is not None:
466
for rev in revision:
467
if rev is None:
468
raise errors.BzrCommandError(
469
gettext('You cannot specify a NULL revision.'))
470
rev_id = rev.as_revision_id(b)
471
self.print_revision(revisions, rev_id)
472
finally:
473
b.repository.unlock()
474
369
475
370
476
class cmd_dump_btree(Command):
371
"""Dump the contents of a btree index file to stdout.
477
__doc__ = """Dump the contents of a btree index file to stdout.
372
478
373
479
PATH is a btree index file, it can be any URL. This includes things like
374
480
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
422
528
self.outf.write(page_bytes[:header_end])
423
529
page_bytes = data
424
530
self.outf.write('\nPage %d\n' % (page_idx,))
425
decomp_bytes = zlib.decompress(page_bytes)
426
self.outf.write(decomp_bytes)
427
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')
428
537
429
538
def _dump_entries(self, trans, basename):
430
539
try:
438
547
for node in bt.iter_all_entries():
439
548
# Node is made up of:
440
549
# (index, key, value, [references])
441
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)
442
556
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
443
557
self.outf.write('%s\n' % (as_tuple,))
444
558
445
559
446
560
class cmd_remove_tree(Command):
447
"""Remove the working tree from a given branch/checkout.
561
__doc__ = """Remove the working tree from a given branch/checkout.
448
562
449
563
Since a lightweight checkout is little more than a working tree
450
564
this will refuse to run against one.
452
566
To re-create the working tree, use "bzr checkout".
453
567
"""
454
568
_see_also = ['checkout', 'working-trees']
455
takes_args = ['location?']
569
takes_args = ['location*']
456
570
takes_options = [
457
571
Option('force',
458
572
help='Remove the working tree even if it has '
459
'uncommitted changes.'),
573
'uncommitted or shelved changes.'),
460
574
]
461
575
462
def run(self, location='.', force=False):
463
d = bzrdir.BzrDir.open(location)
464
576
def run(self, location_list, force=False):
577
if not location_list:
578
location_list=['.']
579
580
for location in location_list:
581
d = controldir.ControlDir.open(location)
582
583
try:
584
working = d.open_workingtree()
585
except errors.NoWorkingTree:
586
raise errors.BzrCommandError(gettext("No working tree to remove"))
587
except errors.NotLocalUrl:
588
raise errors.BzrCommandError(gettext("You cannot remove the working tree"
589
" of a remote path"))
590
if not force:
591
if (working.has_changes()):
592
raise errors.UncommittedChanges(working)
593
if working.get_shelf_manager().last_shelf() is not None:
594
raise errors.ShelvedChanges(working)
595
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"))
599
600
d.destroy_workingtree()
601
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]
465
644
try:
466
working = d.open_workingtree()
467
except errors.NoWorkingTree:
468
raise errors.BzrCommandError("No working tree to remove")
469
except errors.NotLocalUrl:
470
raise errors.BzrCommandError("You cannot remove the working tree"
471
" of a remote path")
472
if not force:
473
if (working.has_changes()):
474
raise errors.UncommittedChanges(working)
475
476
working_path = working.bzrdir.root_transport.base
477
branch_path = working.branch.bzrdir.root_transport.base
478
if working_path != branch_path:
479
raise errors.BzrCommandError("You cannot remove the working tree"
480
" from a lightweight checkout")
481
482
d.destroy_workingtree()
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))
483
653
484
654
485
655
class cmd_revno(Command):
486
"""Show current revision number.
656
__doc__ = """Show current revision number.
487
657
488
658
This is equal to the number of revisions on this branch.
489
659
"""
491
661
_see_also = ['info']
492
662
takes_args = ['location?']
493
663
takes_options = [
494
Option('tree', help='Show revno of working tree'),
664
Option('tree', help='Show revno of working tree.'),
665
'revision',
495
666
]
496
667
497
668
@display_command
498
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
499
674
if tree:
500
675
try:
501
676
wt = WorkingTree.open_containing(location)[0]
502
wt.lock_read()
677
self.add_cleanup(wt.lock_read().unlock)
503
678
except (errors.NoWorkingTree, errors.NotLocalUrl):
504
679
raise errors.NoWorkingTree(location)
505
self.add_cleanup(wt.unlock)
680
b = wt.branch
506
681
revid = wt.last_revision()
507
try:
508
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
509
except errors.NoSuchRevision:
510
revno_t = ('???',)
511
revno = ".".join(str(n) for n in revno_t)
512
682
else:
513
683
b = Branch.open_containing(location)[0]
514
b.lock_read()
515
self.add_cleanup(b.unlock)
516
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)
517
698
self.cleanup_now()
518
self.outf.write(str(revno) + '\n')
699
self.outf.write(revno + '\n')
519
700
520
701
521
702
class cmd_revision_info(Command):
522
"""Show revision number and revision id for a given revision identifier.
703
__doc__ = """Show revision number and revision id for a given revision identifier.
523
704
"""
524
705
hidden = True
525
706
takes_args = ['revision_info*']
526
707
takes_options = [
527
708
'revision',
528
Option('directory',
709
custom_help('directory',
529
710
help='Branch to examine, '
530
'rather than the one containing the working directory.',
531
short_name='d',
532
type=unicode,
533
),
534
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.'),
535
713
]
536
714
537
715
@display_command
541
719
try:
542
720
wt = WorkingTree.open_containing(directory)[0]
543
721
b = wt.branch
544
wt.lock_read()
545
self.add_cleanup(wt.unlock)
722
self.add_cleanup(wt.lock_read().unlock)
546
723
except (errors.NoWorkingTree, errors.NotLocalUrl):
547
724
wt = None
548
725
b = Branch.open_containing(directory)[0]
549
b.lock_read()
550
self.add_cleanup(b.unlock)
726
self.add_cleanup(b.lock_read().unlock)
551
727
revision_ids = []
552
728
if revision is not None:
553
729
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
581
757
582
758
583
759
class cmd_add(Command):
584
"""Add specified files or directories.
760
__doc__ = """Add specified files or directories.
585
761
586
762
In non-recursive mode, all the named items are added, regardless
587
763
of whether they were previously ignored. A warning is given if
595
771
are added. This search proceeds recursively into versioned
596
772
directories. If no names are given '.' is assumed.
597
773
774
A warning will be printed when nested trees are encountered,
775
unless they are explicitly ignored.
776
598
777
Therefore simply saying 'bzr add' will version all files that
599
778
are currently unknown.
600
779
616
795
617
796
Any files matching patterns in the ignore list will not be added
618
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.
619
802
"""
620
803
takes_args = ['file*']
621
804
takes_options = [
622
805
Option('no-recurse',
623
help="Don't recursively add the contents of directories."),
806
help="Don't recursively add the contents of directories.",
807
short_name='N'),
624
808
Option('dry-run',
625
809
help="Show what would be done, but don't actually do anything."),
626
810
'verbose',
648
832
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
649
833
to_file=self.outf, should_print=(not is_quiet()))
650
834
else:
651
action = bzrlib.add.AddAction(to_file=self.outf,
835
action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
652
836
should_print=(not is_quiet()))
653
837
654
838
if base_tree:
655
base_tree.lock_read()
656
self.add_cleanup(base_tree.unlock)
839
self.add_cleanup(base_tree.lock_read().unlock)
657
840
tree, file_list = tree_files_for_add(file_list)
658
841
added, ignored = tree.smart_add(file_list, not
659
842
no_recurse, action=action, save=not dry_run)
662
845
if verbose:
663
846
for glob in sorted(ignored.keys()):
664
847
for path in ignored[glob]:
665
self.outf.write("ignored %s matching \"%s\"\n"
666
% (path, glob))
848
self.outf.write(
849
gettext("ignored {0} matching \"{1}\"\n").format(
850
path, glob))
667
851
668
852
669
853
class cmd_mkdir(Command):
670
"""Create a new versioned directory.
854
__doc__ = """Create a new versioned directory.
671
855
672
856
This is equivalent to creating the directory and then adding it.
673
857
"""
674
858
675
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
]
676
867
encoding_type = 'replace'
677
868
678
def run(self, dir_list):
679
for d in dir_list:
680
os.mkdir(d)
681
wt, dd = WorkingTree.open_containing(d)
682
wt.add([dd])
683
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)
684
898
685
899
686
900
class cmd_relpath(Command):
687
"""Show path of a file relative to root"""
901
__doc__ = """Show path of a file relative to root"""
688
902
689
903
takes_args = ['filename']
690
904
hidden = True
699
913
700
914
701
915
class cmd_inventory(Command):
702
"""Show inventory of the current working copy or a revision.
916
__doc__ = """Show inventory of the current working copy or a revision.
703
917
704
918
It is possible to limit the output to a particular entry
705
919
type using the --kind option. For example: --kind file.
722
936
@display_command
723
937
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
724
938
if kind and kind not in ['file', 'directory', 'symlink']:
725
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
939
raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
726
940
727
941
revision = _get_one_revision('inventory', revision)
728
work_tree, file_list = tree_files(file_list)
729
work_tree.lock_read()
730
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)
731
944
if revision is not None:
732
945
tree = revision.as_tree(work_tree.branch)
733
946
734
947
extra_trees = [work_tree]
735
tree.lock_read()
736
self.add_cleanup(tree.unlock)
948
self.add_cleanup(tree.lock_read().unlock)
737
949
else:
738
950
tree = work_tree
739
951
extra_trees = []
740
952
953
self.add_cleanup(tree.lock_read().unlock)
741
954
if file_list is not None:
742
955
file_ids = tree.paths2ids(file_list, trees=extra_trees,
743
956
require_versioned=True)
744
957
# find_ids_across_trees may include some paths that don't
745
958
# exist in 'tree'.
746
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
747
for file_id in file_ids if file_id in tree)
959
entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
748
960
else:
749
entries = tree.inventory.entries()
961
entries = tree.iter_entries_by_dir()
750
962
751
self.cleanup_now()
752
for path, entry in entries:
963
for path, entry in sorted(entries):
753
964
if kind and kind != entry.kind:
754
965
continue
966
if path == "":
967
continue
755
968
if show_ids:
756
969
self.outf.write('%-50s %s\n' % (path, entry.file_id))
757
970
else:
760
973
761
974
762
975
class cmd_mv(Command):
763
"""Move or rename a file.
976
__doc__ = """Move or rename a file.
764
977
765
978
:Usage:
766
979
bzr mv OLDNAME NEWNAME
793
1006
if auto:
794
1007
return self.run_auto(names_list, after, dry_run)
795
1008
elif dry_run:
796
raise errors.BzrCommandError('--dry-run requires --auto.')
1009
raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
797
1010
if names_list is None:
798
1011
names_list = []
799
1012
if len(names_list) < 2:
800
raise errors.BzrCommandError("missing file argument")
801
tree, rel_names = tree_files(names_list, canonicalize=False)
802
tree.lock_tree_write()
803
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)
804
1019
self._run(tree, names_list, rel_names, after)
805
1020
806
1021
def run_auto(self, names_list, after, dry_run):
807
1022
if names_list is not None and len(names_list) > 1:
808
raise errors.BzrCommandError('Only one path may be specified to'
809
' --auto.')
1023
raise errors.BzrCommandError(gettext('Only one path may be specified to'
1024
' --auto.'))
810
1025
if after:
811
raise errors.BzrCommandError('--after cannot be specified with'
812
' --auto.')
813
work_tree, file_list = tree_files(names_list, default_branch='.')
814
work_tree.lock_tree_write()
815
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)
816
1031
rename_map.RenameMap.guess_renames(work_tree, dry_run)
817
1032
818
1033
def _run(self, tree, names_list, rel_names, after):
827
1042
and rel_names[0].lower() == rel_names[1].lower()):
828
1043
into_existing = False
829
1044
else:
830
inv = tree.inventory
831
1045
# 'fix' the case of a potential 'from'
832
1046
from_id = tree.path2id(
833
1047
tree.get_canonical_inventory_path(rel_names[0]))
834
1048
if (not osutils.lexists(names_list[0]) and
835
from_id and inv.get_file_kind(from_id) == "directory"):
1049
from_id and tree.stored_kind(from_id) == "directory"):
836
1050
into_existing = False
837
1051
# move/rename
838
1052
if into_existing:
845
1059
self.outf.write("%s => %s\n" % (src, dest))
846
1060
else:
847
1061
if len(names_list) != 2:
848
raise errors.BzrCommandError('to mv multiple files the'
1062
raise errors.BzrCommandError(gettext('to mv multiple files the'
849
1063
' destination must be a versioned'
850
' directory')
1064
' directory'))
851
1065
852
1066
# for cicp file-systems: the src references an existing inventory
853
1067
# item:
897
1111
898
1112
899
1113
class cmd_pull(Command):
900
"""Turn this branch into a mirror of another branch.
1114
__doc__ = """Turn this branch into a mirror of another branch.
901
1115
902
1116
By default, this command only works on branches that have not diverged.
903
1117
Branches are considered diverged if the destination branch's most recent
912
1126
match the remote one, use pull --overwrite. This will work even if the two
913
1127
branches have diverged.
914
1128
915
If there is no default location set, the first pull will set it. After
916
that, you can omit the location to use the default. To change the
917
default, use --remember. The value will only be saved if the remote
918
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>.
919
1137
920
1138
Note: The location can be specified either in the form of a branch,
921
1139
or in the form of a path to a file containing a merge directive generated
926
1144
takes_options = ['remember', 'overwrite', 'revision',
927
1145
custom_help('verbose',
928
1146
help='Show logs of pulled revisions.'),
929
Option('directory',
1147
custom_help('directory',
930
1148
help='Branch to pull into, '
931
'rather than the one containing the working directory.',
932
short_name='d',
933
type=unicode,
934
),
1149
'rather than the one containing the working directory.'),
935
1150
Option('local',
936
1151
help="Perform a local pull in a bound "
937
1152
"branch. Local pulls are not applied to "
938
1153
"the master branch."
939
1154
),
1155
Option('show-base',
1156
help="Show base revision text in conflicts."),
1157
Option('overwrite-tags',
1158
help="Overwrite tags only."),
940
1159
]
941
1160
takes_args = ['location?']
942
1161
encoding_type = 'replace'
943
1162
944
def run(self, location=None, remember=False, overwrite=False,
1163
def run(self, location=None, remember=None, overwrite=False,
945
1164
revision=None, verbose=False,
946
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 = []
947
1174
# FIXME: too much stuff is in the command class
948
1175
revision_id = None
949
1176
mergeable = None
952
1179
try:
953
1180
tree_to = WorkingTree.open_containing(directory)[0]
954
1181
branch_to = tree_to.branch
1182
self.add_cleanup(tree_to.lock_write().unlock)
955
1183
except errors.NoWorkingTree:
956
1184
tree_to = None
957
1185
branch_to = Branch.open_containing(directory)[0]
958
1186
self.add_cleanup(branch_to.lock_write().unlock)
1187
if show_base:
1188
warning(gettext("No working tree, ignoring --show-base"))
1189
959
1190
if local and not branch_to.get_bound_location():
960
1191
raise errors.LocalRequiresBoundBranch()
961
1192
970
1201
stored_loc = branch_to.get_parent()
971
1202
if location is None:
972
1203
if stored_loc is None:
973
raise errors.BzrCommandError("No pull location known or"
974
" specified.")
1204
raise errors.BzrCommandError(gettext("No pull location known or"
1205
" specified."))
975
1206
else:
976
1207
display_url = urlutils.unescape_for_display(stored_loc,
977
1208
self.outf.encoding)
978
1209
if not is_quiet():
979
self.outf.write("Using saved parent location: %s\n" % display_url)
1210
self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
980
1211
location = stored_loc
981
1212
982
1213
revision = _get_one_revision('pull', revision)
983
1214
if mergeable is not None:
984
1215
if revision is not None:
985
raise errors.BzrCommandError(
986
'Cannot use -r with merge directives or bundles')
1216
raise errors.BzrCommandError(gettext(
1217
'Cannot use -r with merge directives or bundles'))
987
1218
mergeable.install_revisions(branch_to.repository)
988
1219
base_revision_id, revision_id, verified = \
989
1220
mergeable.get_merge_request(branch_to.repository)
991
1222
else:
992
1223
branch_from = Branch.open(location,
993
1224
possible_transports=possible_transports)
994
995
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
996
1231
branch_to.set_parent(branch_from.base)
997
1232
998
if branch_from is not branch_to:
999
branch_from.lock_read()
1000
self.add_cleanup(branch_from.unlock)
1001
1233
if revision is not None:
1002
1234
revision_id = revision.as_revision_id(branch_from)
1003
1235
1004
branch_to.lock_write()
1005
self.add_cleanup(branch_to.unlock)
1006
1236
if tree_to is not None:
1007
1237
view_info = _get_view_info_for_change_reporter(tree_to)
1008
1238
change_reporter = delta._ChangeReporter(
1010
1240
view_info=view_info)
1011
1241
result = tree_to.pull(
1012
1242
branch_from, overwrite, revision_id, change_reporter,
1013
possible_transports=possible_transports, local=local)
1243
local=local, show_base=show_base)
1014
1244
else:
1015
1245
result = branch_to.pull(
1016
1246
branch_from, overwrite, revision_id, local=local)
1020
1250
log.show_branch_change(
1021
1251
branch_to, self.outf, result.old_revno,
1022
1252
result.old_revid)
1253
if getattr(result, 'tag_conflicts', None):
1254
return 1
1255
else:
1256
return 0
1023
1257
1024
1258
1025
1259
class cmd_push(Command):
1026
"""Update a mirror of this branch.
1260
__doc__ = """Update a mirror of this branch.
1027
1261
1028
1262
The target branch will not have its working tree populated because this
1029
1263
is both expensive, and is not supported on remote file systems.
1042
1276
do a merge (see bzr help merge) from the other branch, and commit that.
1043
1277
After that you will be able to do a push without '--overwrite'.
1044
1278
1045
If there is no default push location set, the first push will set it.
1046
After that, you can omit the location to use the default. To change the
1047
default, use --remember. The value will only be saved if the remote
1048
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>.
1049
1287
"""
1050
1288
1051
1289
_see_also = ['pull', 'update', 'working-trees']
1053
1291
Option('create-prefix',
1054
1292
help='Create the path leading up to the branch '
1055
1293
'if it does not already exist.'),
1056
Option('directory',
1294
custom_help('directory',
1057
1295
help='Branch to push from, '
1058
'rather than the one containing the working directory.',
1059
short_name='d',
1060
type=unicode,
1061
),
1296
'rather than the one containing the working directory.'),
1062
1297
Option('use-existing-dir',
1063
1298
help='By default push will fail if the target'
1064
1299
' directory exists, but does not already'
1075
1310
Option('strict',
1076
1311
help='Refuse to push if there are uncommitted changes in'
1077
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."),
1078
1318
]
1079
1319
takes_args = ['location?']
1080
1320
encoding_type = 'replace'
1081
1321
1082
def run(self, location=None, remember=False, overwrite=False,
1322
def run(self, location=None, remember=None, overwrite=False,
1083
1323
create_prefix=False, verbose=False, revision=None,
1084
1324
use_existing_dir=False, directory=None, stacked_on=None,
1085
stacked=False, strict=None):
1325
stacked=False, strict=None, no_tree=False,
1326
overwrite_tags=False):
1086
1327
from bzrlib.push import _show_push_branch
1087
1328
1329
if overwrite:
1330
overwrite = ["history", "tags"]
1331
elif overwrite_tags:
1332
overwrite = ["tags"]
1333
else:
1334
overwrite = []
1335
1088
1336
if directory is None:
1089
1337
directory = '.'
1090
1338
# Get the source branch
1091
1339
(tree, br_from,
1092
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1093
if strict is None:
1094
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1095
if strict is None: strict = True # default value
1340
_unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1096
1341
# Get the tip's revision_id
1097
1342
revision = _get_one_revision('push', revision)
1098
1343
if revision is not None:
1099
1344
revision_id = revision.in_history(br_from).rev_id
1100
1345
else:
1101
1346
revision_id = None
1102
if strict and tree is not None and revision_id is None:
1103
if (tree.has_changes()):
1104
raise errors.UncommittedChanges(
1105
tree, more='Use --no-strict to force the push.')
1106
if tree.last_revision() != tree.branch.last_revision():
1107
# The tree has lost sync with its branch, there is little
1108
# chance that the user is aware of it but he can still force
1109
# the push with --no-strict
1110
raise errors.OutOfDateTree(
1111
tree, more='Use --no-strict to force the push.')
1112
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.')
1113
1352
# Get the stacked_on branch, if any
1114
1353
if stacked_on is not None:
1115
1354
stacked_on = urlutils.normalize_url(stacked_on)
1125
1364
# error by the feedback given to them. RBC 20080227.
1126
1365
stacked_on = parent_url
1127
1366
if not stacked_on:
1128
raise errors.BzrCommandError(
1129
"Could not determine branch to refer to.")
1367
raise errors.BzrCommandError(gettext(
1368
"Could not determine branch to refer to."))
1130
1369
1131
1370
# Get the destination location
1132
1371
if location is None:
1133
1372
stored_loc = br_from.get_push_location()
1134
1373
if stored_loc is None:
1135
raise errors.BzrCommandError(
1136
"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."))
1137
1384
else:
1138
1385
display_url = urlutils.unescape_for_display(stored_loc,
1139
1386
self.outf.encoding)
1140
self.outf.write("Using saved push location: %s\n" % display_url)
1387
note(gettext("Using saved push location: %s") % display_url)
1141
1388
location = stored_loc
1142
1389
1143
1390
_show_push_branch(br_from, revision_id, location, self.outf,
1144
1391
verbose=verbose, overwrite=overwrite, remember=remember,
1145
1392
stacked_on=stacked_on, create_prefix=create_prefix,
1146
use_existing_dir=use_existing_dir)
1393
use_existing_dir=use_existing_dir, no_tree=no_tree)
1147
1394
1148
1395
1149
1396
class cmd_branch(Command):
1150
"""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.
1151
1398
1152
1399
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1153
1400
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1158
1405
1159
1406
To retrieve the branch as of a particular revision, supply the --revision
1160
1407
parameter, as in "branch foo/bar -r 5".
1408
1409
The synonyms 'clone' and 'get' for this command are deprecated.
1161
1410
"""
1162
1411
1163
1412
_see_also = ['checkout']
1164
1413
takes_args = ['from_location', 'to_location?']
1165
takes_options = ['revision', Option('hardlink',
1166
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."),
1167
1418
Option('no-tree',
1168
1419
help="Create a branch without a working-tree."),
1169
1420
Option('switch',
1187
1438
1188
1439
def run(self, from_location, to_location=None, revision=None,
1189
1440
hardlink=False, stacked=False, standalone=False, no_tree=False,
1190
use_existing_dir=False, switch=False, bind=False):
1441
use_existing_dir=False, switch=False, bind=False,
1442
files_from=None):
1191
1443
from bzrlib import switch as _mod_switch
1192
1444
from bzrlib.tag import _merge_tags_if_possible
1193
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(
1194
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)
1195
1460
revision = _get_one_revision('branch', revision)
1196
br_from.lock_read()
1197
self.add_cleanup(br_from.unlock)
1461
self.add_cleanup(br_from.lock_read().unlock)
1198
1462
if revision is not None:
1199
1463
revision_id = revision.as_revision_id(br_from)
1200
1464
else:
1203
1467
# RBC 20060209
1204
1468
revision_id = br_from.last_revision()
1205
1469
if to_location is None:
1206
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)
1207
1473
to_transport = transport.get_transport(to_location)
1208
1474
try:
1209
1475
to_transport.mkdir('.')
1210
1476
except errors.FileExists:
1211
if not use_existing_dir:
1212
raise errors.BzrCommandError('Target directory "%s" '
1213
'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
1214
1486
else:
1215
1487
try:
1216
bzrdir.BzrDir.open_from_transport(to_transport)
1488
to_dir.open_branch()
1217
1489
except errors.NotBranchError:
1218
1490
pass
1219
1491
else:
1220
1492
raise errors.AlreadyBranchError(to_location)
1221
1493
except errors.NoSuchFile:
1222
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1494
raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
1223
1495
% to_location)
1224
try:
1225
# preserve whatever source format we have.
1226
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1227
possible_transports=[to_transport],
1228
accelerator_tree=accelerator_tree,
1229
hardlink=hardlink, stacked=stacked,
1230
force_new_repo=standalone,
1231
create_tree_if_local=not no_tree,
1232
source_branch=br_from)
1233
branch = dir.open_branch()
1234
except errors.NoSuchRevision:
1235
to_transport.delete_tree('.')
1236
msg = "The branch %s has no revision %s." % (from_location,
1237
revision)
1238
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)
1239
1523
_merge_tags_if_possible(br_from, branch)
1240
1524
# If the source branch is stacked, the new branch may
1241
1525
# be stacked whether we asked for that explicitly or not.
1242
1526
# We therefore need a try/except here and not just 'if stacked:'
1243
1527
try:
1244
note('Created new stacked branch referring to %s.' %
1528
note(gettext('Created new stacked branch referring to %s.') %
1245
1529
branch.get_stacked_on_url())
1246
1530
except (errors.NotStacked, errors.UnstackableBranchFormat,
1247
1531
errors.UnstackableRepositoryFormat), e:
1248
note('Branched %d revision(s).' % branch.revno())
1532
note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1249
1533
if bind:
1250
1534
# Bind to the parent
1251
1535
parent_branch = Branch.open(from_location)
1252
1536
branch.bind(parent_branch)
1253
note('New branch bound to %s' % from_location)
1537
note(gettext('New branch bound to %s') % from_location)
1254
1538
if switch:
1255
1539
# Switch to the new branch
1256
1540
wt, _ = WorkingTree.open_containing('.')
1257
1541
_mod_switch.switch(wt.bzrdir, branch)
1258
note('Switched to branch: %s',
1542
note(gettext('Switched to branch: %s'),
1259
1543
urlutils.unescape_for_display(branch.base, 'utf-8'))
1260
1544
1261
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
1262
1596
class cmd_checkout(Command):
1263
"""Create a new checkout of an existing branch.
1597
__doc__ = """Create a new checkout of an existing branch.
1264
1598
1265
1599
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1266
1600
the branch found in '.'. This is useful if you have removed the working tree
1280
1614
code.)
1281
1615
"""
1282
1616
1283
_see_also = ['checkouts', 'branch']
1617
_see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1284
1618
takes_args = ['branch_location?', 'to_location?']
1285
1619
takes_options = ['revision',
1286
1620
Option('lightweight',
1303
1637
if branch_location is None:
1304
1638
branch_location = osutils.getcwd()
1305
1639
to_location = branch_location
1306
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1640
accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1307
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
1308
1647
revision = _get_one_revision('checkout', revision)
1309
if files_from is not None:
1648
if files_from is not None and files_from != branch_location:
1310
1649
accelerator_tree = WorkingTree.open(files_from)
1311
1650
if revision is not None:
1312
1651
revision_id = revision.as_revision_id(source)
1329
1668
1330
1669
1331
1670
class cmd_renames(Command):
1332
"""Show list of renamed files.
1671
__doc__ = """Show list of renamed files.
1333
1672
"""
1334
1673
# TODO: Option to show renames between two historical versions.
1335
1674
1340
1679
@display_command
1341
1680
def run(self, dir=u'.'):
1342
1681
tree = WorkingTree.open_containing(dir)[0]
1343
tree.lock_read()
1344
self.add_cleanup(tree.unlock)
1345
new_inv = tree.inventory
1682
self.add_cleanup(tree.lock_read().unlock)
1346
1683
old_tree = tree.basis_tree()
1347
old_tree.lock_read()
1348
self.add_cleanup(old_tree.unlock)
1349
old_inv = old_tree.inventory
1684
self.add_cleanup(old_tree.lock_read().unlock)
1350
1685
renames = []
1351
1686
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1352
1687
for f, paths, c, v, p, n, k, e in iterator:
1361
1696
1362
1697
1363
1698
class cmd_update(Command):
1364
"""Update a tree to have the latest code committed to its branch.
1365
1366
This will perform a merge into the working tree, and may generate
1367
conflicts. If you have any local changes, you will still
1368
need to commit them after the update for the update to be complete.
1369
1370
If you want to discard your local changes, you can just do a
1371
'bzr revert' instead of 'bzr commit' after the update.
1372
1373
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
1374
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.
1375
1726
"""
1376
1727
1377
1728
_see_also = ['pull', 'working-trees', 'status-flags']
1378
1729
takes_args = ['dir?']
1379
takes_options = ['revision']
1730
takes_options = ['revision',
1731
Option('show-base',
1732
help="Show base revision text in conflicts."),
1733
]
1380
1734
aliases = ['up']
1381
1735
1382
def run(self, dir='.', revision=None):
1736
def run(self, dir=None, revision=None, show_base=None):
1383
1737
if revision is not None and len(revision) != 1:
1384
raise errors.BzrCommandError(
1385
"bzr update --revision takes exactly one revision")
1386
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"))
1387
1749
branch = tree.branch
1388
1750
possible_transports = []
1389
1751
master = branch.get_master_branch(
1390
1752
possible_transports=possible_transports)
1391
1753
if master is not None:
1392
tree.lock_write()
1393
1754
branch_location = master.base
1755
tree.lock_write()
1394
1756
else:
1757
branch_location = tree.branch.base
1395
1758
tree.lock_tree_write()
1396
branch_location = tree.branch.base
1397
1759
self.add_cleanup(tree.unlock)
1398
1760
# get rid of the final '/' and be ready for display
1399
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1400
self.outf.encoding)
1761
branch_location = urlutils.unescape_for_display(
1762
branch_location.rstrip('/'),
1763
self.outf.encoding)
1401
1764
existing_pending_merges = tree.get_parent_ids()[1:]
1402
1765
if master is None:
1403
1766
old_tip = None
1411
1774
else:
1412
1775
revision_id = branch.last_revision()
1413
1776
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1414
revno = branch.revision_id_to_revno(revision_id)
1415
note("Tree is up to date at revision %d of branch %s" %
1416
(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))
1417
1780
return 0
1418
1781
view_info = _get_view_info_for_change_reporter(tree)
1419
1782
change_reporter = delta._ChangeReporter(
1424
1787
change_reporter,
1425
1788
possible_transports=possible_transports,
1426
1789
revision=revision_id,
1427
old_tip=old_tip)
1790
old_tip=old_tip,
1791
show_base=show_base)
1428
1792
except errors.NoSuchRevision, e:
1429
raise errors.BzrCommandError(
1793
raise errors.BzrCommandError(gettext(
1430
1794
"branch has no revision %s\n"
1431
1795
"bzr update --revision only works"
1432
" for a revision in the branch history"
1796
" for a revision in the branch history")
1433
1797
% (e.revision))
1434
revno = tree.branch.revision_id_to_revno(
1798
revno = tree.branch.revision_id_to_dotted_revno(
1435
1799
_mod_revision.ensure_null(tree.last_revision()))
1436
note('Updated to revision %d of branch %s' %
1437
(revno, branch_location))
1438
if tree.get_parent_ids()[1:] != existing_pending_merges:
1439
note('Your local commits will now show as pending merges with '
1440
"'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'."))
1441
1806
if conflicts != 0:
1442
1807
return 1
1443
1808
else:
1445
1810
1446
1811
1447
1812
class cmd_info(Command):
1448
"""Show information about a working tree, branch or repository.
1813
__doc__ = """Show information about a working tree, branch or repository.
1449
1814
1450
1815
This command will show all known locations and formats associated to the
1451
1816
tree, branch or repository.
1484
1849
else:
1485
1850
noise_level = 0
1486
1851
from bzrlib.info import show_bzrdir_info
1487
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1852
show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1488
1853
verbose=noise_level, outfile=self.outf)
1489
1854
1490
1855
1491
1856
class cmd_remove(Command):
1492
"""Remove files or directories.
1857
__doc__ = """Remove files or directories.
1493
1858
1494
This makes bzr stop tracking changes to the specified files. bzr will delete
1495
them if they can easily be recovered using revert. If no options or
1496
parameters are given bzr will scan for files that are being tracked by bzr
1497
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.
1498
1864
"""
1499
1865
takes_args = ['file*']
1500
1866
takes_options = ['verbose',
1502
1868
RegistryOption.from_kwargs('file-deletion-strategy',
1503
1869
'The file deletion mode to be used.',
1504
1870
title='Deletion Strategy', value_switches=True, enum_switch=False,
1505
safe='Only delete files if they can be'
1506
' safely recovered (default).',
1871
safe='Backup changed files (default).',
1507
1872
keep='Delete from bzr but leave the working copy.',
1508
force='Delete all the specified files, even if they can not be '
1509
'recovered and even if they are non-empty directories.')]
1873
no_backup='Don\'t backup changed files.'),
1874
]
1510
1875
aliases = ['rm', 'del']
1511
1876
encoding_type = 'replace'
1512
1877
1513
1878
def run(self, file_list, verbose=False, new=False,
1514
1879
file_deletion_strategy='safe'):
1515
tree, file_list = tree_files(file_list)
1880
1881
tree, file_list = WorkingTree.open_containing_paths(file_list)
1516
1882
1517
1883
if file_list is not None:
1518
1884
file_list = [f for f in file_list]
1519
1885
1520
tree.lock_write()
1521
self.add_cleanup(tree.unlock)
1886
self.add_cleanup(tree.lock_write().unlock)
1522
1887
# Heuristics should probably all move into tree.remove_smart or
1523
1888
# some such?
1524
1889
if new:
1526
1891
specific_files=file_list).added
1527
1892
file_list = sorted([f[0] for f in added], reverse=True)
1528
1893
if len(file_list) == 0:
1529
raise errors.BzrCommandError('No matching files.')
1894
raise errors.BzrCommandError(gettext('No matching files.'))
1530
1895
elif file_list is None:
1531
1896
# missing files show up in iter_changes(basis) as
1532
1897
# versioned-with-no-kind.
1539
1904
file_deletion_strategy = 'keep'
1540
1905
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1541
1906
keep_files=file_deletion_strategy=='keep',
1542
force=file_deletion_strategy=='force')
1907
force=(file_deletion_strategy=='no-backup'))
1543
1908
1544
1909
1545
1910
class cmd_file_id(Command):
1546
"""Print file_id of a particular file or directory.
1911
__doc__ = """Print file_id of a particular file or directory.
1547
1912
1548
1913
The file_id is assigned when the file is first added and remains the
1549
1914
same through all revisions where the file exists, even when it is
1565
1930
1566
1931
1567
1932
class cmd_file_path(Command):
1568
"""Print path of file_ids to a file or directory.
1933
__doc__ = """Print path of file_ids to a file or directory.
1569
1934
1570
1935
This prints one line for each directory down to the target,
1571
1936
starting at the branch root.
1587
1952
1588
1953
1589
1954
class cmd_reconcile(Command):
1590
"""Reconcile bzr metadata in a branch.
1955
__doc__ = """Reconcile bzr metadata in a branch.
1591
1956
1592
1957
This can correct data mismatches that may have been caused by
1593
1958
previous ghost operations or bzr upgrades. You should only
1607
1972
1608
1973
_see_also = ['check']
1609
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
]
1610
1981
1611
def run(self, branch="."):
1982
def run(self, branch=".", canonicalize_chks=False):
1612
1983
from bzrlib.reconcile import reconcile
1613
dir = bzrdir.BzrDir.open(branch)
1614
reconcile(dir)
1984
dir = controldir.ControlDir.open(branch)
1985
reconcile(dir, canonicalize_chks=canonicalize_chks)
1615
1986
1616
1987
1617
1988
class cmd_revision_history(Command):
1618
"""Display the list of revision ids on a branch."""
1989
__doc__ = """Display the list of revision ids on a branch."""
1619
1990
1620
1991
_see_also = ['log']
1621
1992
takes_args = ['location?']
1625
1996
@display_command
1626
1997
def run(self, location="."):
1627
1998
branch = Branch.open_containing(location)[0]
1628
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):
1629
2004
self.outf.write(revid)
1630
2005
self.outf.write('\n')
1631
2006
1632
2007
1633
2008
class cmd_ancestry(Command):
1634
"""List all revisions merged into this branch."""
2009
__doc__ = """List all revisions merged into this branch."""
1635
2010
1636
2011
_see_also = ['log', 'revision-history']
1637
2012
takes_args = ['location?']
1649
2024
b = wt.branch
1650
2025
last_revision = wt.last_revision()
1651
2026
1652
revision_ids = b.repository.get_ancestry(last_revision)
1653
revision_ids.pop(0)
1654
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
1655
2034
self.outf.write(revision_id + '\n')
1656
2035
1657
2036
1658
2037
class cmd_init(Command):
1659
"""Make a directory into a versioned branch.
2038
__doc__ = """Make a directory into a versioned branch.
1660
2039
1661
2040
Use this to create an empty branch, or before importing an
1662
2041
existing project.
1687
2066
RegistryOption('format',
1688
2067
help='Specify a format for this branch. '
1689
2068
'See "help formats".',
1690
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1691
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),
1692
2071
value_switches=True,
1693
2072
title="Branch format",
1694
2073
),
1695
2074
Option('append-revisions-only',
1696
2075
help='Never change revnos or the existing log.'
1697
' Append revisions to it only.')
2076
' Append revisions to it only.'),
2077
Option('no-tree',
2078
'Create a branch without a working tree.')
1698
2079
]
1699
2080
def run(self, location=None, format=None, append_revisions_only=False,
1700
create_prefix=False):
2081
create_prefix=False, no_tree=False):
1701
2082
if format is None:
1702
format = bzrdir.format_registry.make_bzrdir('default')
2083
format = controldir.format_registry.make_bzrdir('default')
1703
2084
if location is None:
1704
2085
location = u'.'
1705
2086
1714
2095
to_transport.ensure_base()
1715
2096
except errors.NoSuchFile:
1716
2097
if not create_prefix:
1717
raise errors.BzrCommandError("Parent directory of %s"
2098
raise errors.BzrCommandError(gettext("Parent directory of %s"
1718
2099
" does not exist."
1719
2100
"\nYou may supply --create-prefix to create all"
1720
" leading parent directories."
2101
" leading parent directories.")
1721
2102
% location)
1722
2103
to_transport.create_prefix()
1723
2104
1724
2105
try:
1725
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
2106
a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1726
2107
except errors.NotBranchError:
1727
2108
# really a NotBzrDir error...
1728
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
1729
2114
branch = create_branch(to_transport.base, format=format,
1730
possible_transports=[to_transport])
2115
possible_transports=[to_transport],
2116
force_new_tree=force_new_tree)
1731
2117
a_bzrdir = branch.bzrdir
1732
2118
else:
1733
2119
from bzrlib.transport.local import LocalTransport
1737
2123
raise errors.BranchExistsWithoutWorkingTree(location)
1738
2124
raise errors.AlreadyBranchError(location)
1739
2125
branch = a_bzrdir.create_branch()
1740
a_bzrdir.create_workingtree()
2126
if not no_tree and not a_bzrdir.has_workingtree():
2127
a_bzrdir.create_workingtree()
1741
2128
if append_revisions_only:
1742
2129
try:
1743
2130
branch.set_append_revisions_only(True)
1744
2131
except errors.UpgradeRequired:
1745
raise errors.BzrCommandError('This branch format cannot be set'
1746
' to append-revisions-only. Try --default.')
2132
raise errors.BzrCommandError(gettext('This branch format cannot be set'
2133
' to append-revisions-only. Try --default.'))
1747
2134
if not is_quiet():
1748
2135
from bzrlib.info import describe_layout, describe_format
1749
2136
try:
1753
2140
repository = branch.repository
1754
2141
layout = describe_layout(repository, branch, tree).lower()
1755
2142
format = describe_format(a_bzrdir, repository, branch, tree)
1756
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))
1757
2145
if repository.is_shared():
1758
2146
#XXX: maybe this can be refactored into transport.path_or_url()
1759
2147
url = repository.bzrdir.root_transport.external_url()
1761
2149
url = urlutils.local_path_from_url(url)
1762
2150
except errors.InvalidURL:
1763
2151
pass
1764
self.outf.write("Using shared repository: %s\n" % url)
2152
self.outf.write(gettext("Using shared repository: %s\n") % url)
1765
2153
1766
2154
1767
2155
class cmd_init_repository(Command):
1768
"""Create a shared repository for branches to share storage space.
2156
__doc__ = """Create a shared repository for branches to share storage space.
1769
2157
1770
2158
New branches created under the repository directory will store their
1771
2159
revisions in the repository, not in the branch directory. For branches
1797
2185
takes_options = [RegistryOption('format',
1798
2186
help='Specify a format for this repository. See'
1799
2187
' "bzr help formats" for details.',
1800
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1801
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),
1802
2190
value_switches=True, title='Repository format'),
1803
2191
Option('no-trees',
1804
2192
help='Branches in the repository will default to'
1808
2196
1809
2197
def run(self, location, format=None, no_trees=False):
1810
2198
if format is None:
1811
format = bzrdir.format_registry.make_bzrdir('default')
2199
format = controldir.format_registry.make_bzrdir('default')
1812
2200
1813
2201
if location is None:
1814
2202
location = '.'
1815
2203
1816
2204
to_transport = transport.get_transport(location)
1817
to_transport.ensure_base()
1818
2205
1819
newdir = format.initialize_on_transport(to_transport)
1820
repo = newdir.create_repository(shared=True)
1821
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()))
1822
2212
if not is_quiet():
1823
2213
from bzrlib.info import show_bzrdir_info
1824
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
2214
show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1825
2215
1826
2216
1827
2217
class cmd_diff(Command):
1828
"""Show differences in the working tree, between revisions or branches.
2218
__doc__ = """Show differences in the working tree, between revisions or branches.
1829
2219
1830
2220
If no arguments are given, all changes for the current tree are listed.
1831
2221
If files are given, only the changes in those files are listed.
1837
2227
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1838
2228
produces patches suitable for "patch -p1".
1839
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
1840
2237
:Exit values:
1841
2238
1 - changed
1842
2239
2 - unrepresentable changes
1860
2257
1861
2258
bzr diff -r1..3 xxx
1862
2259
1863
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::
1864
2265
1865
2266
bzr diff -cX
1866
2267
1870
2271
1871
2272
bzr diff -r<chosen_parent>..X
1872
2273
1873
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)
1874
2276
1875
bzr diff -c2
2277
bzr diff -r-2..
1876
2278
1877
2279
Show just the differences for file NEWS::
1878
2280
1893
2295
Same as 'bzr diff' but prefix paths with old/ and new/::
1894
2296
1895
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
1896
2302
"""
1897
2303
_see_also = ['status']
1898
2304
takes_args = ['file*']
1917
2323
help='Use this command to compare files.',
1918
2324
type=unicode,
1919
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
),
1920
2335
]
1921
2336
aliases = ['di', 'dif']
1922
2337
encoding_type = 'exact'
1923
2338
1924
2339
@display_command
1925
2340
def run(self, revision=None, file_list=None, diff_options=None,
1926
prefix=None, old=None, new=None, using=None):
1927
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)
1928
2345
1929
2346
if (prefix is None) or (prefix == '0'):
1930
2347
# diff -p0 format
1936
2353
elif ':' in prefix:
1937
2354
old_label, new_label = prefix.split(":")
1938
2355
else:
1939
raise errors.BzrCommandError(
2356
raise errors.BzrCommandError(gettext(
1940
2357
'--prefix expects two values separated by a colon'
1941
' (eg "old/:new/")')
2358
' (eg "old/:new/")'))
1942
2359
1943
2360
if revision and len(revision) > 2:
1944
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1945
' 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'))
1946
2368
1947
2369
(old_tree, new_tree,
1948
2370
old_branch, new_branch,
1949
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1950
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()
1951
2375
return show_diff_trees(old_tree, new_tree, sys.stdout,
1952
2376
specific_files=specific_files,
1953
2377
external_diff_options=diff_options,
1954
2378
old_label=old_label, new_label=new_label,
1955
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)
1956
2383
1957
2384
1958
2385
class cmd_deleted(Command):
1959
"""List files deleted in the working tree.
2386
__doc__ = """List files deleted in the working tree.
1960
2387
"""
1961
2388
# TODO: Show files deleted since a previous revision, or
1962
2389
# between two revisions.
1965
2392
# level of effort but possibly much less IO. (Or possibly not,
1966
2393
# if the directories are very large...)
1967
2394
_see_also = ['status', 'ls']
1968
takes_options = ['show-ids']
2395
takes_options = ['directory', 'show-ids']
1969
2396
1970
2397
@display_command
1971
def run(self, show_ids=False):
1972
tree = WorkingTree.open_containing(u'.')[0]
1973
tree.lock_read()
1974
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)
1975
2401
old = tree.basis_tree()
1976
old.lock_read()
1977
self.add_cleanup(old.unlock)
1978
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():
1979
2404
if not tree.has_id(ie.file_id):
1980
2405
self.outf.write(path)
1981
2406
if show_ids:
1985
2410
1986
2411
1987
2412
class cmd_modified(Command):
1988
"""List files modified in working tree.
2413
__doc__ = """List files modified in working tree.
1989
2414
"""
1990
2415
1991
2416
hidden = True
1992
2417
_see_also = ['status', 'ls']
1993
takes_options = [
1994
Option('null',
1995
help='Write an ascii NUL (\\0) separator '
1996
'between files rather than a newline.')
1997
]
2418
takes_options = ['directory', 'null']
1998
2419
1999
2420
@display_command
2000
def run(self, null=False):
2001
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)
2002
2424
td = tree.changes_from(tree.basis_tree())
2425
self.cleanup_now()
2003
2426
for path, id, kind, text_modified, meta_modified in td.modified:
2004
2427
if null:
2005
2428
self.outf.write(path + '\0')
2008
2431
2009
2432
2010
2433
class cmd_added(Command):
2011
"""List files added in working tree.
2434
__doc__ = """List files added in working tree.
2012
2435
"""
2013
2436
2014
2437
hidden = True
2015
2438
_see_also = ['status', 'ls']
2016
takes_options = [
2017
Option('null',
2018
help='Write an ascii NUL (\\0) separator '
2019
'between files rather than a newline.')
2020
]
2439
takes_options = ['directory', 'null']
2021
2440
2022
2441
@display_command
2023
def run(self, null=False):
2024
wt = WorkingTree.open_containing(u'.')[0]
2025
wt.lock_read()
2026
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)
2027
2445
basis = wt.basis_tree()
2028
basis.lock_read()
2029
self.add_cleanup(basis.unlock)
2030
basis_inv = basis.inventory
2031
inv = wt.inventory
2032
for file_id in inv:
2033
if file_id in basis_inv:
2034
continue
2035
if inv.is_root(file_id) and len(basis_inv) == 0:
2036
continue
2037
path = inv.id2path(file_id)
2038
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):
2039
2455
continue
2040
2456
if null:
2041
2457
self.outf.write(path + '\0')
2044
2460
2045
2461
2046
2462
class cmd_root(Command):
2047
"""Show the tree root directory.
2463
__doc__ = """Show the tree root directory.
2048
2464
2049
2465
The root is the nearest enclosing directory with a .bzr control
2050
2466
directory."""
2061
2477
try:
2062
2478
return int(limitstring)
2063
2479
except ValueError:
2064
msg = "The limit argument must be an integer."
2480
msg = gettext("The limit argument must be an integer.")
2065
2481
raise errors.BzrCommandError(msg)
2066
2482
2067
2483
2069
2485
try:
2070
2486
return int(s)
2071
2487
except ValueError:
2072
msg = "The levels argument must be an integer."
2488
msg = gettext("The levels argument must be an integer.")
2073
2489
raise errors.BzrCommandError(msg)
2074
2490
2075
2491
2076
2492
class cmd_log(Command):
2077
"""Show historical log for a branch or subset of a branch.
2493
__doc__ = """Show historical log for a branch or subset of a branch.
2078
2494
2079
2495
log is bzr's default tool for exploring the history of a branch.
2080
2496
The branch to use is taken from the first parameter. If no parameters
2185
2601
2186
2602
:Other filtering:
2187
2603
2188
The --message option can be used for finding revisions that match a
2189
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.
2190
2609
2191
2610
:Tips & tricks:
2192
2611
2241
2660
help='Show just the specified revision.'
2242
2661
' See also "help revisionspec".'),
2243
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
),
2244
2668
Option('levels',
2245
2669
short_name='n',
2246
2670
help='Number of levels to display - 0 for all, 1 for flat.',
2247
2671
argname='N',
2248
2672
type=_parse_levels),
2249
2673
Option('message',
2250
short_name='m',
2251
2674
help='Show revisions whose message matches this '
2252
2675
'regular expression.',
2253
type=str),
2676
type=str,
2677
hidden=True),
2254
2678
Option('limit',
2255
2679
short_name='l',
2256
2680
help='Limit the output to the first N revisions.',
2259
2683
Option('show-diff',
2260
2684
short_name='p',
2261
2685
help='Show changes made in each revision as a patch.'),
2262
Option('include-merges',
2686
Option('include-merged',
2263
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)
2264
2719
]
2265
2720
encoding_type = 'replace'
2266
2721
2276
2731
message=None,
2277
2732
limit=None,
2278
2733
show_diff=False,
2279
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
):
2280
2746
from bzrlib.log import (
2281
2747
Logger,
2282
2748
make_log_request_dict,
2283
2749
_get_info_for_log_files,
2284
2750
)
2285
2751
direction = (forward and 'forward') or 'reverse'
2286
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:
2287
2772
if levels is None:
2288
2773
levels = 0
2289
2774
else:
2290
raise errors.BzrCommandError(
2291
'--levels and --include-merges are mutually exclusive')
2775
raise errors.BzrCommandError(gettext(
2776
'{0} and {1} are mutually exclusive').format(
2777
'--levels', '--include-merged'))
2292
2778
2293
2779
if change is not None:
2294
2780
if len(change) > 1:
2295
2781
raise errors.RangeInChangeOption()
2296
2782
if revision is not None:
2297
raise errors.BzrCommandError(
2298
'--revision and --change are mutually exclusive')
2783
raise errors.BzrCommandError(gettext(
2784
'{0} and {1} are mutually exclusive').format(
2785
'--revision', '--change'))
2299
2786
else:
2300
2787
revision = change
2301
2788
2304
2791
if file_list:
2305
2792
# find the file ids to log and check for directory filtering
2306
2793
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2307
revision, file_list)
2308
self.add_cleanup(b.unlock)
2794
revision, file_list, self.add_cleanup)
2309
2795
for relpath, file_id, kind in file_info_list:
2310
2796
if file_id is None:
2311
raise errors.BzrCommandError(
2312
"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") %
2313
2799
relpath)
2314
2800
# If the relpath is the top of the tree, we log everything
2315
2801
if relpath == '':
2327
2813
location = revision[0].get_branch()
2328
2814
else:
2329
2815
location = '.'
2330
dir, relpath = bzrdir.BzrDir.open_containing(location)
2816
dir, relpath = controldir.ControlDir.open_containing(location)
2331
2817
b = dir.open_branch()
2332
b.lock_read()
2333
self.add_cleanup(b.unlock)
2818
self.add_cleanup(b.lock_read().unlock)
2334
2819
rev1, rev2 = _get_revision_range(revision, b, self.name())
2335
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
2336
2828
# Decide on the type of delta & diff filtering to use
2337
2829
# TODO: add an --all-files option to make this configurable & consistent
2338
2830
if not verbose:
2356
2848
show_timezone=timezone,
2357
2849
delta_format=get_verbosity_level(),
2358
2850
levels=levels,
2359
show_advice=levels is None)
2851
show_advice=levels is None,
2852
author_list_handler=authors)
2360
2853
2361
2854
# Choose the algorithm for doing the logging. It's annoying
2362
2855
# having multiple code paths like this but necessary until
2374
2867
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2375
2868
or delta_type or partial_history)
2376
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
2377
2882
# Build the LogRequest and execute it
2378
2883
if len(file_ids) == 0:
2379
2884
file_ids = None
2381
2886
direction=direction, specific_fileids=file_ids,
2382
2887
start_revision=rev1, end_revision=rev2, limit=limit,
2383
2888
message_search=message, delta_type=delta_type,
2384
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
)
2385
2893
Logger(b, rqst).show(lf)
2386
2894
2387
2895
2403
2911
# b is taken from revision[0].get_branch(), and
2404
2912
# show_log will use its revision_history. Having
2405
2913
# different branches will lead to weird behaviors.
2406
raise errors.BzrCommandError(
2914
raise errors.BzrCommandError(gettext(
2407
2915
"bzr %s doesn't accept two revisions in different"
2408
" branches." % command_name)
2409
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)
2410
2922
# Avoid loading all of history when we know a missing
2411
2923
# end of range means the last revision ...
2412
2924
if end_spec.spec is None:
2415
2927
else:
2416
2928
rev2 = end_spec.in_history(branch)
2417
2929
else:
2418
raise errors.BzrCommandError(
2419
'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)
2420
2932
return rev1, rev2
2421
2933
2422
2934
2441
2953
2442
2954
2443
2955
class cmd_touching_revisions(Command):
2444
"""Return revision-ids which affected a particular file.
2956
__doc__ = """Return revision-ids which affected a particular file.
2445
2957
2446
2958
A more user-friendly interface is "bzr log FILE".
2447
2959
"""
2454
2966
tree, relpath = WorkingTree.open_containing(filename)
2455
2967
file_id = tree.path2id(relpath)
2456
2968
b = tree.branch
2457
b.lock_read()
2458
self.add_cleanup(b.unlock)
2969
self.add_cleanup(b.lock_read().unlock)
2459
2970
touching_revs = log.find_touching_revisions(b, file_id)
2460
2971
for revno, revision_id, what in touching_revs:
2461
2972
self.outf.write("%6d %s\n" % (revno, what))
2462
2973
2463
2974
2464
2975
class cmd_ls(Command):
2465
"""List files in a tree.
2976
__doc__ = """List files in a tree.
2466
2977
"""
2467
2978
2468
2979
_see_also = ['status', 'cat']
2474
2985
help='Recurse into subdirectories.'),
2475
2986
Option('from-root',
2476
2987
help='Print paths relative to the root of the branch.'),
2477
Option('unknown', help='Print unknown files.'),
2988
Option('unknown', short_name='u',
2989
help='Print unknown files.'),
2478
2990
Option('versioned', help='Print versioned files.',
2479
2991
short_name='V'),
2480
Option('ignored', help='Print ignored files.'),
2481
Option('null',
2482
help='Write an ascii NUL (\\0) separator '
2483
'between files rather than a newline.'),
2484
Option('kind',
2992
Option('ignored', short_name='i',
2993
help='Print ignored files.'),
2994
Option('kind', short_name='k',
2485
2995
help='List entries of a particular kind: file, directory, symlink.',
2486
2996
type=unicode),
2997
'null',
2487
2998
'show-ids',
2999
'directory',
2488
3000
]
2489
3001
@display_command
2490
3002
def run(self, revision=None, verbose=False,
2491
3003
recursive=False, from_root=False,
2492
3004
unknown=False, versioned=False, ignored=False,
2493
null=False, kind=None, show_ids=False, path=None):
3005
null=False, kind=None, show_ids=False, path=None, directory=None):
2494
3006
2495
3007
if kind and kind not in ('file', 'directory', 'symlink'):
2496
raise errors.BzrCommandError('invalid kind specified')
3008
raise errors.BzrCommandError(gettext('invalid kind specified'))
2497
3009
2498
3010
if verbose and null:
2499
raise errors.BzrCommandError('Cannot set both --verbose and --null')
3011
raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2500
3012
all = not (unknown or versioned or ignored)
2501
3013
2502
3014
selection = {'I':ignored, '?':unknown, 'V':versioned}
2505
3017
fs_path = '.'
2506
3018
else:
2507
3019
if from_root:
2508
raise errors.BzrCommandError('cannot specify both --from-root'
2509
' and PATH')
3020
raise errors.BzrCommandError(gettext('cannot specify both --from-root'
3021
' and PATH'))
2510
3022
fs_path = path
2511
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2512
fs_path)
3023
tree, branch, relpath = \
3024
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2513
3025
2514
3026
# Calculate the prefix to use
2515
3027
prefix = None
2528
3040
if view_files:
2529
3041
apply_view = True
2530
3042
view_str = views.view_display_str(view_files)
2531
note("Ignoring files outside view. View is %s" % view_str)
3043
note(gettext("Ignoring files outside view. View is %s") % view_str)
2532
3044
2533
tree.lock_read()
2534
self.add_cleanup(tree.unlock)
3045
self.add_cleanup(tree.lock_read().unlock)
2535
3046
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2536
3047
from_dir=relpath, recursive=recursive):
2537
3048
# Apply additional masking
2579
3090
2580
3091
2581
3092
class cmd_unknowns(Command):
2582
"""List unknown files.
3093
__doc__ = """List unknown files.
2583
3094
"""
2584
3095
2585
3096
hidden = True
2586
3097
_see_also = ['ls']
3098
takes_options = ['directory']
2587
3099
2588
3100
@display_command
2589
def run(self):
2590
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():
2591
3103
self.outf.write(osutils.quotefn(f) + '\n')
2592
3104
2593
3105
2594
3106
class cmd_ignore(Command):
2595
"""Ignore specified files or patterns.
3107
__doc__ = """Ignore specified files or patterns.
2596
3108
2597
3109
See ``bzr help patterns`` for details on the syntax of patterns.
2598
3110
2607
3119
using this command or directly by using an editor, be sure to commit
2608
3120
it.
2609
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
2610
3128
Patterns prefixed with '!' are exceptions to ignore patterns and take
2611
3129
precedence over regular ignores. Such exceptions are used to specify
2612
3130
files that should be versioned which would otherwise be ignored.
2614
3132
Patterns prefixed with '!!' act as regular ignore patterns, but have
2615
3133
precedence over the '!' exception patterns.
2616
3134
2617
Note: ignore patterns containing shell wildcards must be quoted from
2618
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.
2619
3142
2620
3143
:Examples:
2621
3144
Ignore the top level Makefile::
2630
3153
2631
3154
bzr ignore "!special.class"
2632
3155
3156
Ignore files whose name begins with the "#" character::
3157
3158
bzr ignore "RE:^#"
3159
2633
3160
Ignore .o files under the lib directory::
2634
3161
2635
3162
bzr ignore "lib/**/*.o"
2643
3170
bzr ignore "RE:(?!debian/).*"
2644
3171
2645
3172
Ignore everything except the "local" toplevel directory,
2646
but always ignore "*~" autosave files, even under local/::
3173
but always ignore autosave files ending in ~, even under local/::
2647
3174
2648
3175
bzr ignore "*"
2649
3176
bzr ignore "!./local"
2652
3179
2653
3180
_see_also = ['status', 'ignored', 'patterns']
2654
3181
takes_args = ['name_pattern*']
2655
takes_options = [
2656
Option('old-default-rules',
2657
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.')
2658
3185
]
2659
3186
2660
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'.'):
2661
3189
from bzrlib import ignores
2662
if old_default_rules is not None:
2663
# dump the rules and exit
2664
for pattern in ignores.OLD_DEFAULTS:
2665
print pattern
3190
if default_rules is not None:
3191
# dump the default rules and exit
3192
for pattern in ignores.USER_DEFAULTS:
3193
self.outf.write("%s\n" % pattern)
2666
3194
return
2667
3195
if not name_pattern_list:
2668
raise errors.BzrCommandError("ignore requires at least one "
2669
"NAME_PATTERN or --old-default-rules")
3196
raise errors.BzrCommandError(gettext("ignore requires at least one "
3197
"NAME_PATTERN or --default-rules."))
2670
3198
name_pattern_list = [globbing.normalize_pattern(p)
2671
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('')
2672
3212
for name_pattern in name_pattern_list:
2673
3213
if (name_pattern[0] == '/' or
2674
3214
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2675
raise errors.BzrCommandError(
2676
"NAME_PATTERN should not be an absolute path")
2677
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)
2678
3218
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2679
3219
ignored = globbing.Globster(name_pattern_list)
2680
3220
matches = []
2681
tree.lock_read()
3221
self.add_cleanup(tree.lock_read().unlock)
2682
3222
for entry in tree.list_files():
2683
3223
id = entry[3]
2684
3224
if id is not None:
2685
3225
filename = entry[0]
2686
3226
if ignored.match(filename):
2687
matches.append(filename.encode('utf-8'))
2688
tree.unlock()
3227
matches.append(filename)
2689
3228
if len(matches) > 0:
2690
print "Warning: the following files are version controlled and" \
2691
" match your ignore pattern:\n%s" \
2692
"\nThese files will continue to be version controlled" \
2693
" unless you 'bzr remove' them." % ("\n".join(matches),)
3229
self.outf.write(gettext("Warning: the following files are version "
3230
"controlled and match your ignore pattern:\n%s"
3231
"\nThese files will continue to be version controlled"
3232
" unless you 'bzr remove' them.\n") % ("\n".join(matches),))
2694
3233
2695
3234
2696
3235
class cmd_ignored(Command):
2697
"""List ignored files and the patterns that matched them.
3236
__doc__ = """List ignored files and the patterns that matched them.
2698
3237
2699
3238
List all the ignored files and the ignore pattern that caused the file to
2700
3239
be ignored.
2706
3245
2707
3246
encoding_type = 'replace'
2708
3247
_see_also = ['ignore', 'ls']
3248
takes_options = ['directory']
2709
3249
2710
3250
@display_command
2711
def run(self):
2712
tree = WorkingTree.open_containing(u'.')[0]
2713
tree.lock_read()
2714
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)
2715
3254
for path, file_class, kind, file_id, entry in tree.list_files():
2716
3255
if file_class != 'I':
2717
3256
continue
2721
3260
2722
3261
2723
3262
class cmd_lookup_revision(Command):
2724
"""Lookup the revision-id from a revision-number
3263
__doc__ = """Lookup the revision-id from a revision-number
2725
3264
2726
3265
:Examples:
2727
3266
bzr lookup-revision 33
2728
3267
"""
2729
3268
hidden = True
2730
3269
takes_args = ['revno']
3270
takes_options = ['directory']
2731
3271
2732
3272
@display_command
2733
def run(self, revno):
3273
def run(self, revno, directory=u'.'):
2734
3274
try:
2735
3275
revno = int(revno)
2736
3276
except ValueError:
2737
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2738
2739
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
3277
raise errors.BzrCommandError(gettext("not a valid revision-number: %r")
3278
% revno)
3279
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
3280
self.outf.write("%s\n" % revid)
2740
3281
2741
3282
2742
3283
class cmd_export(Command):
2743
"""Export current or past revision to a destination directory or archive.
3284
__doc__ = """Export current or past revision to a destination directory or archive.
2744
3285
2745
3286
If no revision is specified this exports the last committed revision.
2746
3287
2767
3308
zip .zip
2768
3309
================= =========================
2769
3310
"""
3311
encoding = 'exact'
2770
3312
takes_args = ['dest', 'branch_or_subdir?']
2771
takes_options = [
3313
takes_options = ['directory',
2772
3314
Option('format',
2773
3315
help="Type of file to export to.",
2774
3316
type=unicode),
2778
3320
Option('root',
2779
3321
type=str,
2780
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.'),
2781
3329
]
2782
3330
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2783
root=None, filters=False):
3331
root=None, filters=False, per_file_timestamps=False, uncommitted=False,
3332
directory=u'.'):
2784
3333
from bzrlib.export import export
2785
3334
2786
3335
if branch_or_subdir is None:
2787
tree = WorkingTree.open_containing(u'.')[0]
2788
b = tree.branch
2789
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
2790
3348
else:
2791
b, subdir = Branch.open_containing(branch_or_subdir)
2792
tree = None
2793
2794
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)
2795
3350
try:
2796
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)
2797
3353
except errors.NoSuchExportFormat, e:
2798
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3354
raise errors.BzrCommandError(
3355
gettext('Unsupported export format: %s') % e.format)
2799
3356
2800
3357
2801
3358
class cmd_cat(Command):
2802
"""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.
2803
3360
2804
3361
If no revision is nominated, the last revision is used.
2805
3362
2808
3365
"""
2809
3366
2810
3367
_see_also = ['ls']
2811
takes_options = [
3368
takes_options = ['directory',
2812
3369
Option('name-from-revision', help='The path name in the old tree.'),
2813
3370
Option('filters', help='Apply content filters to display the '
2814
3371
'convenience form.'),
2819
3376
2820
3377
@display_command
2821
3378
def run(self, filename, revision=None, name_from_revision=False,
2822
filters=False):
3379
filters=False, directory=None):
2823
3380
if revision is not None and len(revision) != 1:
2824
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2825
" one revision specifier")
3381
raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
3382
" one revision specifier"))
2826
3383
tree, branch, relpath = \
2827
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2828
branch.lock_read()
2829
self.add_cleanup(branch.unlock)
3384
_open_directory_or_containing_tree_or_branch(filename, directory)
3385
self.add_cleanup(branch.lock_read().unlock)
2830
3386
return self._run(tree, branch, relpath, filename, revision,
2831
3387
name_from_revision, filters)
2832
3388
2835
3391
if tree is None:
2836
3392
tree = b.basis_tree()
2837
3393
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2838
rev_tree.lock_read()
2839
self.add_cleanup(rev_tree.unlock)
3394
self.add_cleanup(rev_tree.lock_read().unlock)
2840
3395
2841
3396
old_file_id = rev_tree.path2id(relpath)
2842
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.
2843
3402
if name_from_revision:
2844
3403
# Try in revision if requested
2845
3404
if old_file_id is None:
2846
raise errors.BzrCommandError(
2847
"%r is not present in revision %s" % (
3405
raise errors.BzrCommandError(gettext(
3406
"{0!r} is not present in revision {1}").format(
2848
3407
filename, rev_tree.get_revision_id()))
2849
3408
else:
2850
content = rev_tree.get_file_text(old_file_id)
3409
actual_file_id = old_file_id
2851
3410
else:
2852
3411
cur_file_id = tree.path2id(relpath)
2853
found = False
2854
if cur_file_id is not None:
2855
# Then try with the actual file id
2856
try:
2857
content = rev_tree.get_file_text(cur_file_id)
2858
found = True
2859
except errors.NoSuchId:
2860
# The actual file id didn't exist at that time
2861
pass
2862
if not found and old_file_id is not None:
2863
# Finally try with the old file id
2864
content = rev_tree.get_file_text(old_file_id)
2865
found = True
2866
if not found:
2867
# Can't be found anywhere
2868
raise errors.BzrCommandError(
2869
"%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(
2870
3419
filename, rev_tree.get_revision_id()))
2871
3420
if filtered:
2872
from bzrlib.filters import (
2873
ContentFilterContext,
2874
filtered_output_bytes,
2875
)
2876
filters = rev_tree._content_filter_stack(relpath)
2877
chunks = content.splitlines(True)
2878
content = filtered_output_bytes(chunks, filters,
2879
ContentFilterContext(relpath, rev_tree))
2880
self.cleanup_now()
2881
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)
2882
3425
else:
2883
self.cleanup_now()
2884
self.outf.write(content)
3426
content = rev_tree.get_file_text(actual_file_id)
3427
self.cleanup_now()
3428
self.outf.write(content)
2885
3429
2886
3430
2887
3431
class cmd_local_time_offset(Command):
2888
"""Show the offset in seconds from GMT to local time."""
3432
__doc__ = """Show the offset in seconds from GMT to local time."""
2889
3433
hidden = True
2890
3434
@display_command
2891
3435
def run(self):
2892
print osutils.local_time_offset()
3436
self.outf.write("%s\n" % osutils.local_time_offset())
2893
3437
2894
3438
2895
3439
2896
3440
class cmd_commit(Command):
2897
"""Commit changes into a new revision.
3441
__doc__ = """Commit changes into a new revision.
2898
3442
2899
3443
An explanatory message needs to be given for each commit. This is
2900
3444
often done by using the --message option (getting the message from the
2948
3492
to trigger updates to external systems like bug trackers. The --fixes
2949
3493
option can be used to record the association between a revision and
2950
3494
one or more bugs. See ``bzr help bugs`` for details.
2951
2952
A selective commit may fail in some cases where the committed
2953
tree would be invalid. Consider::
2954
2955
bzr init foo
2956
mkdir foo/bar
2957
bzr add foo/bar
2958
bzr commit foo -m "committing foo"
2959
bzr mv foo/bar foo/baz
2960
mkdir foo/bar
2961
bzr add foo/bar
2962
bzr commit foo/bar -m "committing bar but not baz"
2963
2964
In the example above, the last commit will fail by design. This gives
2965
the user the opportunity to decide whether they want to commit the
2966
rename at the same time, separately first, or not at all. (As a general
2967
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2968
3495
"""
2969
# TODO: Run hooks on tree to-be-committed, and after commit.
2970
2971
# TODO: Strict commit that fails if there are deleted files.
2972
# (what does "deleted files" mean ??)
2973
2974
# TODO: Give better message for -s, --summary, used by tla people
2975
2976
# XXX: verbose currently does nothing
2977
3496
2978
3497
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
2979
3498
takes_args = ['selected*']
3008
3527
"the master branch until a normal commit "
3009
3528
"is performed."
3010
3529
),
3011
Option('show-diff',
3530
Option('show-diff', short_name='p',
3012
3531
help='When no message is supplied, show the diff along'
3013
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.'),
3014
3537
]
3015
3538
aliases = ['ci', 'checkin']
3016
3539
3017
3540
def _iter_bug_fix_urls(self, fixes, branch):
3541
default_bugtracker = None
3018
3542
# Configure the properties for bug fixing attributes.
3019
3543
for fixed_bug in fixes:
3020
3544
tokens = fixed_bug.split(':')
3021
if len(tokens) != 2:
3022
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(
3023
3561
"Invalid bug %s. Must be in the form of 'tracker:id'. "
3024
3562
"See \"bzr help bugs\" for more information on this "
3025
"feature.\nCommit refused." % fixed_bug)
3026
tag, bug_id = tokens
3563
"feature.\nCommit refused.") % fixed_bug)
3564
else:
3565
tag, bug_id = tokens
3027
3566
try:
3028
3567
yield bugtracker.get_bug_url(tag, branch, bug_id)
3029
3568
except errors.UnknownBugTrackerAbbreviation:
3030
raise errors.BzrCommandError(
3031
'Unrecognized bug %s. Commit refused.' % fixed_bug)
3569
raise errors.BzrCommandError(gettext(
3570
'Unrecognized bug %s. Commit refused.') % fixed_bug)
3032
3571
except errors.MalformedBugIdentifier, e:
3033
raise errors.BzrCommandError(
3034
"%s\nCommit refused." % (str(e),))
3572
raise errors.BzrCommandError(gettext(
3573
"%s\nCommit refused.") % (str(e),))
3035
3574
3036
3575
def run(self, message=None, file=None, verbose=False, selected_list=None,
3037
3576
unchanged=False, strict=False, local=False, fixes=None,
3038
author=None, show_diff=False, exclude=None, commit_time=None):
3577
author=None, show_diff=False, exclude=None, commit_time=None,
3578
lossy=False):
3039
3579
from bzrlib.errors import (
3040
3580
PointlessCommit,
3041
3581
ConflictsInTree,
3044
3584
from bzrlib.msgeditor import (
3045
3585
edit_commit_message_encoded,
3046
3586
generate_commit_message_template,
3047
make_commit_message_template_encoded
3587
make_commit_message_template_encoded,
3588
set_commit_message,
3048
3589
)
3049
3590
3050
3591
commit_stamp = offset = None
3052
3593
try:
3053
3594
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3054
3595
except ValueError, e:
3055
raise errors.BzrCommandError(
3056
"Could not parse --commit-time: " + str(e))
3057
3058
# TODO: Need a blackbox test for invoking the external editor; may be
3059
# slightly problematic to run this cross-platform.
3060
3061
# TODO: do more checks that the commit will succeed before
3062
# spending the user's valuable time typing a commit message.
3596
raise errors.BzrCommandError(gettext(
3597
"Could not parse --commit-time: " + str(e)))
3063
3598
3064
3599
properties = {}
3065
3600
3066
tree, selected_list = tree_files(selected_list)
3601
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3067
3602
if selected_list == ['']:
3068
3603
# workaround - commit of root of tree should be exactly the same
3069
3604
# as just default commit in that tree, and succeed even though
3094
3629
'(use --file "%(f)s" to take commit message from that file)'
3095
3630
% { 'f': message })
3096
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"))
3097
3638
3098
3639
def get_message(commit_obj):
3099
3640
"""Callback to get commit message"""
3100
my_message = message
3101
if my_message is not None and '\r' in my_message:
3102
my_message = my_message.replace('\r\n', '\n')
3103
my_message = my_message.replace('\r', '\n')
3104
if my_message is None and not file:
3105
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,
3106
3653
selected_list, diff=show_diff,
3107
3654
output_encoding=osutils.get_user_encoding())
3108
start_message = generate_commit_message_template(commit_obj)
3109
my_message = edit_commit_message_encoded(t,
3110
start_message=start_message)
3111
if my_message is None:
3112
raise errors.BzrCommandError("please specify a commit"
3113
" message with either --message or --file")
3114
elif my_message and file:
3115
raise errors.BzrCommandError(
3116
"please specify either --message or --file")
3117
if file:
3118
my_message = codecs.open(file, 'rt',
3119
osutils.get_user_encoding()).read()
3120
if my_message == "":
3121
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 \"\"."))
3122
3673
return my_message
3123
3674
3124
3675
# The API permits a commit with a filter of [] to mean 'select nothing'
3132
3683
reporter=None, verbose=verbose, revprops=properties,
3133
3684
authors=author, timestamp=commit_stamp,
3134
3685
timezone=offset,
3135
exclude=safe_relpath_files(tree, exclude))
3686
exclude=tree.safe_relpath_files(exclude),
3687
lossy=lossy)
3136
3688
except PointlessCommit:
3137
# FIXME: This should really happen before the file is read in;
3138
# perhaps prepare the commit; get the message; then actually commit
3139
raise errors.BzrCommandError("No changes to commit."
3140
" 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."))
3141
3692
except ConflictsInTree:
3142
raise errors.BzrCommandError('Conflicts detected in working '
3693
raise errors.BzrCommandError(gettext('Conflicts detected in working '
3143
3694
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3144
' resolve.')
3695
' resolve.'))
3145
3696
except StrictCommitFailed:
3146
raise errors.BzrCommandError("Commit refused because there are"
3147
" unknown files in the working tree.")
3697
raise errors.BzrCommandError(gettext("Commit refused because there are"
3698
" unknown files in the working tree."))
3148
3699
except errors.BoundBranchOutOfDate, e:
3149
raise errors.BzrCommandError(str(e) + "\n"
3150
'To commit to master branch, run update and then commit.\n'
3151
'You can also pass --local to commit to continue working '
3152
'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
3153
3705
3154
3706
3155
3707
class cmd_check(Command):
3156
"""Validate working tree structure, branch consistency and repository history.
3708
__doc__ = """Validate working tree structure, branch consistency and repository history.
3157
3709
3158
3710
This command checks various invariants about branch and repository storage
3159
3711
to detect data corruption or bzr bugs.
3223
3775
3224
3776
3225
3777
class cmd_upgrade(Command):
3226
"""Upgrade branch storage to current format.
3227
3228
The check command or bzr developers may sometimes advise you to run
3229
this command. When the default format has changed you may also be warned
3230
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/.
3231
3808
"""
3232
3809
3233
_see_also = ['check']
3810
_see_also = ['check', 'reconcile', 'formats']
3234
3811
takes_args = ['url?']
3235
3812
takes_options = [
3236
RegistryOption('format',
3237
help='Upgrade to a specific format. See "bzr help'
3238
' formats" for details.',
3239
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3240
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3241
value_switches=True, title='Branch format'),
3242
]
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
]
3243
3824
3244
def run(self, url='.', format=None):
3825
def run(self, url='.', format=None, clean=False, dry_run=False):
3245
3826
from bzrlib.upgrade import upgrade
3246
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
3247
3834
3248
3835
3249
3836
class cmd_whoami(Command):
3250
"""Show or set bzr user id.
3837
__doc__ = """Show or set bzr user id.
3251
3838
3252
3839
:Examples:
3253
3840
Show the email of the current user::
3258
3845
3259
3846
bzr whoami "Frank Chu <fchu@example.com>"
3260
3847
"""
3261
takes_options = [ Option('email',
3848
takes_options = [ 'directory',
3849
Option('email',
3262
3850
help='Display email address only.'),
3263
3851
Option('branch',
3264
3852
help='Set identity for the current branch instead of '
3268
3856
encoding_type = 'replace'
3269
3857
3270
3858
@display_command
3271
def run(self, email=False, branch=False, name=None):
3859
def run(self, email=False, branch=False, name=None, directory=None):
3272
3860
if name is None:
3273
# use branch if we're inside one; otherwise global config
3274
try:
3275
c = Branch.open_containing('.')[0].get_config()
3276
except errors.NotBranchError:
3277
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')
3278
3870
if email:
3279
self.outf.write(c.user_email() + '\n')
3871
self.outf.write(_mod_config.extract_email_address(identity)
3872
+ '\n')
3280
3873
else:
3281
self.outf.write(c.username() + '\n')
3874
self.outf.write(identity + '\n')
3282
3875
return
3283
3876
3877
if email:
3878
raise errors.BzrCommandError(gettext("--email can only be used to display existing "
3879
"identity"))
3880
3284
3881
# display a warning if an email address isn't included in the given name.
3285
3882
try:
3286
config.extract_email_address(name)
3883
_mod_config.extract_email_address(name)
3287
3884
except errors.NoEmailInUsername, e:
3288
3885
warning('"%s" does not seem to contain an email address. '
3289
3886
'This is allowed, but not recommended.', name)
3290
3887
3291
3888
# use global config unless --branch given
3292
3889
if branch:
3293
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()
3294
3896
else:
3295
c = config.GlobalConfig()
3296
c.set_user_option('email', name)
3897
c = _mod_config.GlobalStack()
3898
c.set('email', name)
3297
3899
3298
3900
3299
3901
class cmd_nick(Command):
3300
"""Print or set the branch nickname.
3902
__doc__ = """Print or set the branch nickname.
3301
3903
3302
If unset, the tree root directory name is used as the nickname.
3303
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.
3304
3907
3305
3908
Bound branches use the nickname of its master branch unless it is set
3306
3909
locally.
3308
3911
3309
3912
_see_also = ['info']
3310
3913
takes_args = ['nickname?']
3311
def run(self, nickname=None):
3312
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]
3313
3917
if nickname is None:
3314
3918
self.printme(branch)
3315
3919
else:
3317
3921
3318
3922
@display_command
3319
3923
def printme(self, branch):
3320
print branch.nick
3924
self.outf.write('%s\n' % branch.nick)
3321
3925
3322
3926
3323
3927
class cmd_alias(Command):
3324
"""Set/unset and display aliases.
3928
__doc__ = """Set/unset and display aliases.
3325
3929
3326
3930
:Examples:
3327
3931
Show the current aliases::
3360
3964
3361
3965
def remove_alias(self, alias_name):
3362
3966
if alias_name is None:
3363
raise errors.BzrCommandError(
3364
'bzr alias --remove expects an alias to remove.')
3967
raise errors.BzrCommandError(gettext(
3968
'bzr alias --remove expects an alias to remove.'))
3365
3969
# If alias is not found, print something like:
3366
3970
# unalias: foo: not found
3367
c = config.GlobalConfig()
3971
c = _mod_config.GlobalConfig()
3368
3972
c.unset_alias(alias_name)
3369
3973
3370
3974
@display_command
3371
3975
def print_aliases(self):
3372
3976
"""Print out the defined aliases in a similar format to bash."""
3373
aliases = config.GlobalConfig().get_aliases()
3977
aliases = _mod_config.GlobalConfig().get_aliases()
3374
3978
for key, value in sorted(aliases.iteritems()):
3375
3979
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3376
3980
3386
3990
3387
3991
def set_alias(self, alias_name, alias_command):
3388
3992
"""Save the alias in the global config."""
3389
c = config.GlobalConfig()
3993
c = _mod_config.GlobalConfig()
3390
3994
c.set_alias(alias_name, alias_command)
3391
3995
3392
3996
3393
3997
class cmd_selftest(Command):
3394
"""Run internal test suite.
3998
__doc__ = """Run internal test suite.
3395
3999
3396
4000
If arguments are given, they are regular expressions that say which tests
3397
4001
should run. Tests matching any expression are run, and other tests are
3427
4031
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3428
4032
into a pdb postmortem session.
3429
4033
4034
The --coverage=DIRNAME global option produces a report with covered code
4035
indicated.
4036
3430
4037
:Examples:
3431
4038
Run only tests relating to 'ignore'::
3432
4039
3441
4048
def get_transport_type(typestring):
3442
4049
"""Parse and return a transport specifier."""
3443
4050
if typestring == "sftp":
3444
from bzrlib.transport.sftp import SFTPAbsoluteServer
3445
return SFTPAbsoluteServer
3446
if typestring == "memory":
3447
from bzrlib.transport.memory import MemoryServer
3448
return MemoryServer
3449
if typestring == "fakenfs":
3450
from bzrlib.transport.fakenfs import FakeNFSServer
3451
return FakeNFSServer
4051
from bzrlib.tests import stub_sftp
4052
return stub_sftp.SFTPAbsoluteServer
4053
elif typestring == "memory":
4054
from bzrlib.tests import test_server
4055
return memory.MemoryServer
4056
elif typestring == "fakenfs":
4057
from bzrlib.tests import test_server
4058
return test_server.FakeNFSServer
3452
4059
msg = "No known transport type %s. Supported types are: sftp\n" %\
3453
4060
(typestring)
3454
4061
raise errors.BzrCommandError(msg)
3465
4072
'throughout the test suite.',
3466
4073
type=get_transport_type),
3467
4074
Option('benchmark',
3468
help='Run the benchmarks rather than selftests.'),
4075
help='Run the benchmarks rather than selftests.',
4076
hidden=True),
3469
4077
Option('lsprof-timed',
3470
4078
help='Generate lsprof output for benchmarked'
3471
4079
' sections of code.'),
3472
4080
Option('lsprof-tests',
3473
4081
help='Generate lsprof output for each test.'),
3474
Option('cache-dir', type=str,
3475
help='Cache intermediate benchmark output in this '
3476
'directory.'),
3477
4082
Option('first',
3478
4083
help='Run all tests, but run specified tests first.',
3479
4084
short_name='f',
3488
4093
Option('randomize', type=str, argname="SEED",
3489
4094
help='Randomize the order of tests using the given'
3490
4095
' seed or "now" for the current time.'),
3491
Option('exclude', type=str, argname="PATTERN",
3492
short_name='x',
3493
help='Exclude tests that match this regular'
3494
' expression.'),
4096
ListOption('exclude', type=str, argname="PATTERN",
4097
short_name='x',
4098
help='Exclude tests that match this regular'
4099
' expression.'),
3495
4100
Option('subunit',
3496
4101
help='Output test progress via subunit.'),
3497
4102
Option('strict', help='Fail on missing dependencies or '
3504
4109
param_name='starting_with', short_name='s',
3505
4110
help=
3506
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.")
3507
4115
]
3508
4116
encoding_type = 'replace'
3509
4117
3513
4121
3514
4122
def run(self, testspecs_list=None, verbose=False, one=False,
3515
4123
transport=None, benchmark=None,
3516
lsprof_timed=None, cache_dir=None,
4124
lsprof_timed=None,
3517
4125
first=False, list_only=False,
3518
4126
randomize=None, exclude=None, strict=False,
3519
4127
load_list=None, debugflag=None, starting_with=None, subunit=False,
3520
parallel=None, lsprof_tests=False):
3521
from bzrlib.tests import selftest
3522
import bzrlib.benchmarks as benchmarks
3523
from bzrlib.benchmarks import tree_creator
3524
3525
# Make deprecation warnings visible, unless -Werror is set
3526
symbol_versioning.activate_deprecation_warnings(override=False)
3527
3528
if cache_dir is not None:
3529
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
3530
4141
if testspecs_list is not None:
3531
4142
pattern = '|'.join(testspecs_list)
3532
4143
else:
3535
4146
try:
3536
4147
from bzrlib.tests import SubUnitBzrRunner
3537
4148
except ImportError:
3538
raise errors.BzrCommandError("subunit not available. subunit "
3539
"needs to be installed to use --subunit.")
4149
raise errors.BzrCommandError(gettext("subunit not available. subunit "
4150
"needs to be installed to use --subunit."))
3540
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)
3541
4161
if parallel:
3542
4162
self.additional_selftest_args.setdefault(
3543
4163
'suite_decorators', []).append(parallel)
3544
4164
if benchmark:
3545
test_suite_factory = benchmarks.test_suite
3546
# Unless user explicitly asks for quiet, be verbose in benchmarks
3547
verbose = not is_quiet()
3548
# TODO: should possibly lock the history file...
3549
benchfile = open(".perf_history", "at", buffering=1)
3550
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
3551
4171
else:
3552
test_suite_factory = None
3553
benchfile = None
4172
exclude_pattern = '(' + '|'.join(exclude) + ')'
4173
if not sync:
4174
self._disable_fsync()
3554
4175
selftest_kwargs = {"verbose": verbose,
3555
4176
"pattern": pattern,
3556
4177
"stop_on_failure": one,
3558
4179
"test_suite_factory": test_suite_factory,
3559
4180
"lsprof_timed": lsprof_timed,
3560
4181
"lsprof_tests": lsprof_tests,
3561
"bench_history": benchfile,
3562
4182
"matching_tests_first": first,
3563
4183
"list_only": list_only,
3564
4184
"random_seed": randomize,
3565
"exclude_pattern": exclude,
4185
"exclude_pattern": exclude_pattern,
3566
4186
"strict": strict,
3567
4187
"load_list": load_list,
3568
4188
"debug_flags": debugflag,
3569
4189
"starting_with": starting_with
3570
4190
}
3571
4191
selftest_kwargs.update(self.additional_selftest_args)
3572
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()
3573
4200
return int(not result)
3574
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
3575
4211
3576
4212
class cmd_version(Command):
3577
"""Show version of bzr."""
4213
__doc__ = """Show version of bzr."""
3578
4214
3579
4215
encoding_type = 'replace'
3580
4216
takes_options = [
3591
4227
3592
4228
3593
4229
class cmd_rocks(Command):
3594
"""Statement of optimism."""
4230
__doc__ = """Statement of optimism."""
3595
4231
3596
4232
hidden = True
3597
4233
3598
4234
@display_command
3599
4235
def run(self):
3600
print "It sure does!"
4236
self.outf.write(gettext("It sure does!\n"))
3601
4237
3602
4238
3603
4239
class cmd_find_merge_base(Command):
3604
"""Find and print a base revision for merging two branches."""
4240
__doc__ = """Find and print a base revision for merging two branches."""
3605
4241
# TODO: Options to specify revisions on either side, as if
3606
4242
# merging only part of the history.
3607
4243
takes_args = ['branch', 'other']
3613
4249
3614
4250
branch1 = Branch.open_containing(branch)[0]
3615
4251
branch2 = Branch.open_containing(other)[0]
3616
branch1.lock_read()
3617
self.add_cleanup(branch1.unlock)
3618
branch2.lock_read()
3619
self.add_cleanup(branch2.unlock)
4252
self.add_cleanup(branch1.lock_read().unlock)
4253
self.add_cleanup(branch2.lock_read().unlock)
3620
4254
last1 = ensure_null(branch1.last_revision())
3621
4255
last2 = ensure_null(branch2.last_revision())
3622
4256
3623
4257
graph = branch1.repository.get_graph(branch2.repository)
3624
4258
base_rev_id = graph.find_unique_lca(last1, last2)
3625
4259
3626
print 'merge base is revision %s' % base_rev_id
4260
self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
3627
4261
3628
4262
3629
4263
class cmd_merge(Command):
3630
"""Perform a three-way merge.
4264
__doc__ = """Perform a three-way merge.
3631
4265
3632
4266
The source of the merge can be specified either in the form of a branch,
3633
4267
or in the form of a path to a file containing a merge directive generated
3634
4268
with bzr send. If neither is specified, the default is the upstream branch
3635
or the branch most recently merged using --remember.
3636
3637
When merging a branch, by default the tip will be merged. To pick a different
3638
revision, pass --revision. If you specify two values, the first will be used as
3639
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3640
available revisions, like this is commonly referred to as "cherrypicking".
3641
3642
Revision numbers are always relative to the branch being merged.
3643
3644
By default, bzr will try to merge in all new work from the other
3645
branch, automatically determining an appropriate base. If this
3646
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.
3647
4290
3648
4291
Merge will do its best to combine the changes in two branches, but there
3649
4292
are some kinds of problems only a human can fix. When it encounters those,
3650
4293
it will mark a conflict. A conflict means that you need to fix something,
3651
before you should commit.
4294
before you can commit.
3652
4295
3653
4296
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
3654
4297
3655
If there is no default branch set, the first merge will set it. After
3656
that, you can omit the branch to use the default. To change the
3657
default, use --remember. The value will only be saved if the remote
3658
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.
3659
4302
3660
4303
The results of the merge are placed into the destination working
3661
4304
directory, where they can be reviewed (with bzr diff), tested, and then
3662
4305
committed to record the result of the merge.
3663
4306
3664
4307
merge refuses to run if there are any uncommitted changes, unless
3665
--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
3666
4311
merge revision which has more than two parents.
3667
4312
3668
4313
If one would like to merge changes from the working tree of the other
3673
4318
you to apply each diff hunk and file change, similar to "shelve".
3674
4319
3675
4320
:Examples:
3676
To merge the latest revision from bzr.dev::
4321
To merge all new revisions from bzr.dev::
3677
4322
3678
4323
bzr merge ../bzr.dev
3679
4324
3716
4361
' completely merged into the source, pull from the'
3717
4362
' source rather than merging. When this happens,'
3718
4363
' you do not need to commit the result.'),
3719
Option('directory',
4364
custom_help('directory',
3720
4365
help='Branch to merge into, '
3721
'rather than the one containing the working directory.',
3722
short_name='d',
3723
type=unicode,
3724
),
4366
'rather than the one containing the working directory.'),
3725
4367
Option('preview', help='Instead of merging, show a diff of the'
3726
4368
' merge.'),
3727
4369
Option('interactive', help='Select changes interactively.',
3729
4371
]
3730
4372
3731
4373
def run(self, location=None, revision=None, force=False,
3732
merge_type=None, show_base=False, reprocess=None, remember=False,
4374
merge_type=None, show_base=False, reprocess=None, remember=None,
3733
4375
uncommitted=False, pull=False,
3734
4376
directory=None,
3735
4377
preview=False,
3743
4385
merger = None
3744
4386
allow_pending = True
3745
4387
verified = 'inapplicable'
4388
3746
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'))
3747
4393
3748
4394
try:
3749
4395
basis_tree = tree.revision_tree(tree.last_revision())
3760
4406
unversioned_filter=tree.is_ignored, view_info=view_info)
3761
4407
pb = ui.ui_factory.nested_progress_bar()
3762
4408
self.add_cleanup(pb.finished)
3763
tree.lock_write()
3764
self.add_cleanup(tree.unlock)
4409
self.add_cleanup(tree.lock_write().unlock)
3765
4410
if location is not None:
3766
4411
try:
3767
4412
mergeable = bundle.read_mergeable_from_url(location,
3770
4415
mergeable = None
3771
4416
else:
3772
4417
if uncommitted:
3773
raise errors.BzrCommandError('Cannot use --uncommitted'
3774
' with bundles or merge directives.')
4418
raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
4419
' with bundles or merge directives.'))
3775
4420
3776
4421
if revision is not None:
3777
raise errors.BzrCommandError(
3778
'Cannot use -r with merge directives or bundles')
4422
raise errors.BzrCommandError(gettext(
4423
'Cannot use -r with merge directives or bundles'))
3779
4424
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3780
mergeable, pb)
4425
mergeable, None)
3781
4426
3782
4427
if merger is None and uncommitted:
3783
4428
if revision is not None and len(revision) > 0:
3784
raise errors.BzrCommandError('Cannot use --uncommitted and'
3785
' --revision at the same time.')
3786
merger = self.get_merger_from_uncommitted(tree, location, pb)
4429
raise errors.BzrCommandError(gettext('Cannot use --uncommitted and'
4430
' --revision at the same time.'))
4431
merger = self.get_merger_from_uncommitted(tree, location, None)
3787
4432
allow_pending = False
3788
4433
3789
4434
if merger is None:
3790
4435
merger, allow_pending = self._get_merger_from_branch(tree,
3791
location, revision, remember, possible_transports, pb)
4436
location, revision, remember, possible_transports, None)
3792
4437
3793
4438
merger.merge_type = merge_type
3794
4439
merger.reprocess = reprocess
3796
4441
self.sanity_check_merger(merger)
3797
4442
if (merger.base_rev_id == merger.other_rev_id and
3798
4443
merger.other_rev_id is not None):
3799
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.'))
3800
4452
return 0
3801
if pull:
4453
if pull and not preview:
3802
4454
if merger.interesting_files is not None:
3803
raise errors.BzrCommandError('Cannot pull individual files')
4455
raise errors.BzrCommandError(gettext('Cannot pull individual files'))
3804
4456
if (merger.base_rev_id == tree.last_revision()):
3805
4457
result = tree.pull(merger.other_branch, False,
3806
4458
merger.other_rev_id)
3807
4459
result.report(self.outf)
3808
4460
return 0
3809
4461
if merger.this_basis is None:
3810
raise errors.BzrCommandError(
4462
raise errors.BzrCommandError(gettext(
3811
4463
"This branch has no commits."
3812
" (perhaps you would prefer 'bzr pull')")
4464
" (perhaps you would prefer 'bzr pull')"))
3813
4465
if preview:
3814
4466
return self._do_preview(merger)
3815
4467
elif interactive:
3828
4480
def _do_preview(self, merger):
3829
4481
from bzrlib.diff import show_diff_trees
3830
4482
result_tree = self._get_preview(merger)
4483
path_encoding = osutils.get_diff_header_encoding()
3831
4484
show_diff_trees(merger.this_tree, result_tree, self.outf,
3832
old_label='', new_label='')
4485
old_label='', new_label='',
4486
path_encoding=path_encoding)
3833
4487
3834
4488
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3835
4489
merger.change_reporter = change_reporter
3864
4518
def sanity_check_merger(self, merger):
3865
4519
if (merger.show_base and
3866
4520
not merger.merge_type is _mod_merge.Merge3Merger):
3867
raise errors.BzrCommandError("Show-base is not supported for this"
3868
" 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)
3869
4523
if merger.reprocess is None:
3870
4524
if merger.show_base:
3871
4525
merger.reprocess = False
3873
4527
# Use reprocess if the merger supports it
3874
4528
merger.reprocess = merger.merge_type.supports_reprocess
3875
4529
if merger.reprocess and not merger.merge_type.supports_reprocess:
3876
raise errors.BzrCommandError("Conflict reduction is not supported"
3877
" for merge type %s." %
4530
raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
4531
" for merge type %s.") %
3878
4532
merger.merge_type)
3879
4533
if merger.reprocess and merger.show_base:
3880
raise errors.BzrCommandError("Cannot do conflict reduction and"
3881
" show base.")
4534
raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
4535
" show base."))
3882
4536
3883
4537
def _get_merger_from_branch(self, tree, location, revision, remember,
3884
4538
possible_transports, pb):
3911
4565
if other_revision_id is None:
3912
4566
other_revision_id = _mod_revision.ensure_null(
3913
4567
other_branch.last_revision())
3914
# Remember where we merge from
3915
if ((remember or tree.branch.get_submit_branch() is None) and
3916
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)))):
3917
4577
tree.branch.set_submit_branch(other_branch.base)
3918
_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)
3919
4581
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3920
4582
other_revision_id, base_revision_id, other_branch, base_branch)
3921
4583
if other_path != '':
3980
4642
stored_location_type = "parent"
3981
4643
mutter("%s", stored_location)
3982
4644
if stored_location is None:
3983
raise errors.BzrCommandError("No location specified or remembered")
4645
raise errors.BzrCommandError(gettext("No location specified or remembered"))
3984
4646
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
3985
note(u"%s remembered %s location %s", verb_string,
3986
stored_location_type, display_url)
4647
note(gettext("{0} remembered {1} location {2}").format(verb_string,
4648
stored_location_type, display_url))
3987
4649
return stored_location
3988
4650
3989
4651
3990
4652
class cmd_remerge(Command):
3991
"""Redo a merge.
4653
__doc__ = """Redo a merge.
3992
4654
3993
4655
Use this if you want to try a different merge technique while resolving
3994
4656
conflicts. Some merge techniques are better than others, and remerge
4019
4681
4020
4682
def run(self, file_list=None, merge_type=None, show_base=False,
4021
4683
reprocess=False):
4684
from bzrlib.conflicts import restore
4022
4685
if merge_type is None:
4023
4686
merge_type = _mod_merge.Merge3Merger
4024
tree, file_list = tree_files(file_list)
4025
tree.lock_write()
4026
self.add_cleanup(tree.unlock)
4687
tree, file_list = WorkingTree.open_containing_paths(file_list)
4688
self.add_cleanup(tree.lock_write().unlock)
4027
4689
parents = tree.get_parent_ids()
4028
4690
if len(parents) != 2:
4029
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4691
raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4030
4692
" merges. Not cherrypicking or"
4031
" multi-merges.")
4693
" multi-merges."))
4032
4694
repository = tree.branch.repository
4033
4695
interesting_ids = None
4034
4696
new_conflicts = []
4043
4705
if tree.kind(file_id) != "directory":
4044
4706
continue
4045
4707
4046
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):
4047
4710
interesting_ids.add(ie.file_id)
4048
4711
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4049
4712
else:
4065
4728
# list, we imply that the working tree text has seen and rejected
4066
4729
# all the changes from the other tree, when in fact those changes
4067
4730
# have not yet been seen.
4068
pb = ui.ui_factory.nested_progress_bar()
4069
4731
tree.set_parent_ids(parents[:1])
4070
4732
try:
4071
merger = _mod_merge.Merger.from_revision_ids(pb,
4072
tree, parents[1])
4733
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4073
4734
merger.interesting_ids = interesting_ids
4074
4735
merger.merge_type = merge_type
4075
4736
merger.show_base = show_base
4077
4738
conflicts = merger.do_merge()
4078
4739
finally:
4079
4740
tree.set_parent_ids(parents)
4080
pb.finished()
4081
4741
if conflicts > 0:
4082
4742
return 1
4083
4743
else:
4085
4745
4086
4746
4087
4747
class cmd_revert(Command):
4088
"""Revert files to a previous revision.
4748
__doc__ = """\
4749
Set files in the working tree back to the contents of a previous revision.
4089
4750
4090
4751
Giving a list of files will revert only those files. Otherwise, all files
4091
4752
will be reverted. If the revision is not specified with '--revision', the
4092
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.
4093
4756
4094
4757
To remove only some changes, without reverting to a prior version, use
4095
merge instead. For example, "merge . --revision -2..-3" will remove the
4096
changes introduced by -2, without affecting the changes introduced by -1.
4097
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.
4098
4765
4099
By default, any files that have been manually changed will be backed up
4100
first. (Files changed only by merge are not backed up.) Backup files have
4101
'.~#~' 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.
4102
4770
4103
4771
When you provide files, you can use their current pathname or the pathname
4104
4772
from the target revision. So you can use revert to "undelete" a file by
4130
4798
target branches.
4131
4799
"""
4132
4800
4133
_see_also = ['cat', 'export']
4801
_see_also = ['cat', 'export', 'merge', 'shelve']
4134
4802
takes_options = [
4135
4803
'revision',
4136
4804
Option('no-backup', "Do not save backups of reverted files."),
4141
4809
4142
4810
def run(self, revision=None, no_backup=False, file_list=None,
4143
4811
forget_merges=None):
4144
tree, file_list = tree_files(file_list)
4145
tree.lock_write()
4146
self.add_cleanup(tree.unlock)
4812
tree, file_list = WorkingTree.open_containing_paths(file_list)
4813
self.add_cleanup(tree.lock_tree_write().unlock)
4147
4814
if forget_merges:
4148
4815
tree.set_parent_ids(tree.get_parent_ids()[:1])
4149
4816
else:
4152
4819
@staticmethod
4153
4820
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4154
4821
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4155
pb = ui.ui_factory.nested_progress_bar()
4156
try:
4157
tree.revert(file_list, rev_tree, not no_backup, pb,
4158
report_changes=True)
4159
finally:
4160
pb.finished()
4822
tree.revert(file_list, rev_tree, not no_backup, None,
4823
report_changes=True)
4161
4824
4162
4825
4163
4826
class cmd_assert_fail(Command):
4164
"""Test reporting of assertion failures"""
4827
__doc__ = """Test reporting of assertion failures"""
4165
4828
# intended just for use in testing
4166
4829
4167
4830
hidden = True
4171
4834
4172
4835
4173
4836
class cmd_help(Command):
4174
"""Show help on a command or other topic.
4837
__doc__ = """Show help on a command or other topic.
4175
4838
"""
4176
4839
4177
4840
_see_also = ['topics']
4190
4853
4191
4854
4192
4855
class cmd_shell_complete(Command):
4193
"""Show appropriate completions for context.
4856
__doc__ = """Show appropriate completions for context.
4194
4857
4195
4858
For a list of all available commands, say 'bzr shell-complete'.
4196
4859
"""
4200
4863
4201
4864
@display_command
4202
4865
def run(self, context=None):
4203
import shellcomplete
4866
from bzrlib import shellcomplete
4204
4867
shellcomplete.shellcomplete(context)
4205
4868
4206
4869
4207
4870
class cmd_missing(Command):
4208
"""Show unmerged/unpulled revisions between two branches.
4871
__doc__ = """Show unmerged/unpulled revisions between two branches.
4209
4872
4210
4873
OTHER_BRANCH may be local or remote.
4211
4874
4242
4905
_see_also = ['merge', 'pull']
4243
4906
takes_args = ['other_branch?']
4244
4907
takes_options = [
4908
'directory',
4245
4909
Option('reverse', 'Reverse the order of revisions.'),
4246
4910
Option('mine-only',
4247
4911
'Display changes in the local branch only.'),
4259
4923
type=_parse_revision_str,
4260
4924
help='Filter on local branch revisions (inclusive). '
4261
4925
'See "help revisionspec" for details.'),
4262
Option('include-merges',
4926
Option('include-merged',
4263
4927
'Show all revisions in addition to the mainline ones.'),
4928
Option('include-merges', hidden=True,
4929
help='Historical alias for --include-merged.'),
4264
4930
]
4265
4931
encoding_type = 'replace'
4266
4932
4269
4935
theirs_only=False,
4270
4936
log_format=None, long=False, short=False, line=False,
4271
4937
show_ids=False, verbose=False, this=False, other=False,
4272
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):
4273
4941
from bzrlib.missing import find_unmerged, iter_log_revisions
4274
4942
def message(s):
4275
4943
if not is_quiet():
4276
4944
self.outf.write(s)
4277
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
4278
4961
if this:
4279
4962
mine_only = this
4280
4963
if other:
4288
4971
elif theirs_only:
4289
4972
restrict = 'remote'
4290
4973
4291
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
4292
4977
parent = local_branch.get_parent()
4293
4978
if other_branch is None:
4294
4979
other_branch = parent
4295
4980
if other_branch is None:
4296
raise errors.BzrCommandError("No peer location known"
4297
" or specified.")
4981
raise errors.BzrCommandError(gettext("No peer location known"
4982
" or specified."))
4298
4983
display_url = urlutils.unescape_for_display(parent,
4299
4984
self.outf.encoding)
4300
message("Using saved parent location: "
4301
+ display_url + "\n")
4985
message(gettext("Using saved parent location: {0}\n").format(
4986
display_url))
4302
4987
4303
4988
remote_branch = Branch.open(other_branch)
4304
4989
if remote_branch.base == local_branch.base:
4305
4990
remote_branch = local_branch
4991
else:
4992
self.add_cleanup(remote_branch.lock_read().unlock)
4306
4993
4307
local_branch.lock_read()
4308
self.add_cleanup(local_branch.unlock)
4309
4994
local_revid_range = _revision_range_to_revid_range(
4310
4995
_get_revision_range(my_revision, local_branch,
4311
4996
self.name()))
4312
4997
4313
remote_branch.lock_read()
4314
self.add_cleanup(remote_branch.unlock)
4315
4998
remote_revid_range = _revision_range_to_revid_range(
4316
4999
_get_revision_range(revision,
4317
5000
remote_branch, self.name()))
4319
5002
local_extra, remote_extra = find_unmerged(
4320
5003
local_branch, remote_branch, restrict,
4321
5004
backward=not reverse,
4322
include_merges=include_merges,
5005
include_merged=include_merged,
4323
5006
local_revid_range=local_revid_range,
4324
5007
remote_revid_range=remote_revid_range)
4325
5008
4332
5015
4333
5016
status_code = 0
4334
5017
if local_extra and not theirs_only:
4335
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)) %
4336
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()
4337
5025
for revision in iter_log_revisions(local_extra,
4338
5026
local_branch.repository,
4339
verbose):
5027
verbose,
5028
rev_tag_dict):
4340
5029
lf.log_revision(revision)
4341
5030
printed_local = True
4342
5031
status_code = 1
4346
5035
if remote_extra and not mine_only:
4347
5036
if printed_local is True:
4348
5037
message("\n\n\n")
4349
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)) %
4350
5041
len(remote_extra))
5042
if remote_branch.supports_tags():
5043
rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
4351
5044
for revision in iter_log_revisions(remote_extra,
4352
5045
remote_branch.repository,
4353
verbose):
5046
verbose,
5047
rev_tag_dict):
4354
5048
lf.log_revision(revision)
4355
5049
status_code = 1
4356
5050
4357
5051
if mine_only and not local_extra:
4358
5052
# We checked local, and found nothing extra
4359
message('This branch is up to date.\n')
5053
message(gettext('This branch has no new revisions.\n'))
4360
5054
elif theirs_only and not remote_extra:
4361
5055
# We checked remote, and found nothing extra
4362
message('Other branch is up to date.\n')
5056
message(gettext('Other branch has no new revisions.\n'))
4363
5057
elif not (mine_only or theirs_only or local_extra or
4364
5058
remote_extra):
4365
5059
# We checked both branches, and neither one had extra
4366
5060
# revisions
4367
message("Branches are up to date.\n")
5061
message(gettext("Branches are up to date.\n"))
4368
5062
self.cleanup_now()
4369
5063
if not status_code and parent is None and other_branch is not None:
4370
local_branch.lock_write()
4371
self.add_cleanup(local_branch.unlock)
5064
self.add_cleanup(local_branch.lock_write().unlock)
4372
5065
# handle race conditions - a parent might be set while we run.
4373
5066
if local_branch.get_parent() is None:
4374
5067
local_branch.set_parent(remote_branch.base)
4376
5069
4377
5070
4378
5071
class cmd_pack(Command):
4379
"""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
"""
4380
5089
4381
5090
_see_also = ['repositories']
4382
5091
takes_args = ['branch_or_repo?']
5092
takes_options = [
5093
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
5094
]
4383
5095
4384
def run(self, branch_or_repo='.'):
4385
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]
4386
5098
try:
4387
5099
branch = dir.open_branch()
4388
5100
repository = branch.repository
4389
5101
except errors.NotBranchError:
4390
5102
repository = dir.open_repository()
4391
repository.pack()
5103
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4392
5104
4393
5105
4394
5106
class cmd_plugins(Command):
4395
"""List the installed plugins.
5107
__doc__ = """List the installed plugins.
4396
5108
4397
5109
This command displays the list of installed plugins including
4398
5110
version of plugin and a short description of each.
4414
5126
4415
5127
@display_command
4416
5128
def run(self, verbose=False):
4417
import bzrlib.plugin
4418
from inspect import getdoc
4419
result = []
4420
for name, plugin in bzrlib.plugin.plugins().items():
4421
version = plugin.__version__
4422
if version == 'unknown':
4423
version = ''
4424
name_ver = '%s %s' % (name, version)
4425
d = getdoc(plugin.module)
4426
if d:
4427
doc = d.split('\n')[0]
4428
else:
4429
doc = '(no description)'
4430
result.append((name_ver, doc, plugin.path()))
4431
for name_ver, doc, path in sorted(result):
4432
print name_ver
4433
print ' ', doc
4434
if verbose:
4435
print ' ', path
4436
print
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)))
4437
5133
4438
5134
4439
5135
class cmd_testament(Command):
4440
"""Show testament (signing-form) of a revision."""
5136
__doc__ = """Show testament (signing-form) of a revision."""
4441
5137
takes_options = [
4442
5138
'revision',
4443
5139
Option('long', help='Produce long-format testament.'),
4444
5140
Option('strict',
4445
5141
help='Produce a strict-format testament.')]
4446
5142
takes_args = ['branch?']
5143
encoding_type = 'exact'
4447
5144
@display_command
4448
5145
def run(self, branch=u'.', revision=None, long=False, strict=False):
4449
5146
from bzrlib.testament import Testament, StrictTestament
4455
5152
b = Branch.open_containing(branch)[0]
4456
5153
else:
4457
5154
b = Branch.open(branch)
4458
b.lock_read()
4459
self.add_cleanup(b.unlock)
5155
self.add_cleanup(b.lock_read().unlock)
4460
5156
if revision is None:
4461
5157
rev_id = b.last_revision()
4462
5158
else:
4463
5159
rev_id = revision[0].as_revision_id(b)
4464
5160
t = testament_class.from_revision(b.repository, rev_id)
4465
5161
if long:
4466
sys.stdout.writelines(t.as_text_lines())
5162
self.outf.writelines(t.as_text_lines())
4467
5163
else:
4468
sys.stdout.write(t.as_short_text())
5164
self.outf.write(t.as_short_text())
4469
5165
4470
5166
4471
5167
class cmd_annotate(Command):
4472
"""Show the origin of each line in a file.
5168
__doc__ = """Show the origin of each line in a file.
4473
5169
4474
5170
This prints out the given file with an annotation on the left side
4475
5171
indicating which revision, author and date introduced the change.
4486
5182
Option('long', help='Show commit date in annotations.'),
4487
5183
'revision',
4488
5184
'show-ids',
5185
'directory',
4489
5186
]
4490
5187
encoding_type = 'exact'
4491
5188
4492
5189
@display_command
4493
5190
def run(self, filename, all=False, long=False, revision=None,
4494
show_ids=False):
4495
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
)
4496
5195
wt, branch, relpath = \
4497
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
5196
_open_directory_or_containing_tree_or_branch(filename, directory)
4498
5197
if wt is not None:
4499
wt.lock_read()
4500
self.add_cleanup(wt.unlock)
5198
self.add_cleanup(wt.lock_read().unlock)
4501
5199
else:
4502
branch.lock_read()
4503
self.add_cleanup(branch.unlock)
5200
self.add_cleanup(branch.lock_read().unlock)
4504
5201
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4505
tree.lock_read()
4506
self.add_cleanup(tree.unlock)
4507
if wt is not None:
5202
self.add_cleanup(tree.lock_read().unlock)
5203
if wt is not None and revision is None:
4508
5204
file_id = wt.path2id(relpath)
4509
5205
else:
4510
5206
file_id = tree.path2id(relpath)
4511
5207
if file_id is None:
4512
5208
raise errors.NotVersionedError(filename)
4513
file_version = tree.inventory[file_id].revision
4514
5209
if wt is not None and revision is None:
4515
5210
# If there is a tree and we're not annotating historical
4516
5211
# versions, annotate the working tree's content.
4517
5212
annotate_file_tree(wt, file_id, self.outf, long, all,
4518
5213
show_ids=show_ids)
4519
5214
else:
4520
annotate_file(branch, file_version, file_id, long, all, self.outf,
4521
show_ids=show_ids)
5215
annotate_file_tree(tree, file_id, self.outf, long, all,
5216
show_ids=show_ids, branch=branch)
4522
5217
4523
5218
4524
5219
class cmd_re_sign(Command):
4525
"""Create a digital signature for an existing revision."""
5220
__doc__ = """Create a digital signature for an existing revision."""
4526
5221
# TODO be able to replace existing ones.
4527
5222
4528
5223
hidden = True # is this right ?
4529
5224
takes_args = ['revision_id*']
4530
takes_options = ['revision']
5225
takes_options = ['directory', 'revision']
4531
5226
4532
def run(self, revision_id_list=None, revision=None):
5227
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4533
5228
if revision_id_list is not None and revision is not None:
4534
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'))
4535
5230
if revision_id_list is None and revision is None:
4536
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4537
b = WorkingTree.open_containing(u'.')[0].branch
4538
b.lock_write()
4539
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)
4540
5234
return self._run(b, revision_id_list, revision)
4541
5235
4542
5236
def _run(self, b, revision_id_list, revision):
4543
5237
import bzrlib.gpg as gpg
4544
gpg_strategy = gpg.GPGStrategy(b.get_config())
5238
gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4545
5239
if revision_id_list is not None:
4546
5240
b.repository.start_write_group()
4547
5241
try:
4572
5266
if to_revid is None:
4573
5267
to_revno = b.revno()
4574
5268
if from_revno is None or to_revno is None:
4575
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'))
4576
5270
b.repository.start_write_group()
4577
5271
try:
4578
5272
for revno in range(from_revno, to_revno + 1):
4584
5278
else:
4585
5279
b.repository.commit_write_group()
4586
5280
else:
4587
raise errors.BzrCommandError('Please supply either one revision, or a range.')
5281
raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4588
5282
4589
5283
4590
5284
class cmd_bind(Command):
4591
"""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.
4592
5287
4593
5288
Once converted into a checkout, commits must succeed on the master branch
4594
5289
before they will be applied to the local branch.
4600
5295
4601
5296
_see_also = ['checkouts', 'unbind']
4602
5297
takes_args = ['location?']
4603
takes_options = []
5298
takes_options = ['directory']
4604
5299
4605
def run(self, location=None):
4606
b, relpath = Branch.open_containing(u'.')
5300
def run(self, location=None, directory=u'.'):
5301
b, relpath = Branch.open_containing(directory)
4607
5302
if location is None:
4608
5303
try:
4609
5304
location = b.get_old_bound_location()
4610
5305
except errors.UpgradeRequired:
4611
raise errors.BzrCommandError('No location supplied. '
4612
'This format does not remember old locations.')
5306
raise errors.BzrCommandError(gettext('No location supplied. '
5307
'This format does not remember old locations.'))
4613
5308
else:
4614
5309
if location is None:
4615
raise errors.BzrCommandError('No location supplied and no '
4616
'previous location known')
5310
if b.get_bound_location() is not None:
5311
raise errors.BzrCommandError(
5312
gettext('Branch is already bound'))
5313
else:
5314
raise errors.BzrCommandError(
5315
gettext('No location supplied'
5316
' and no previous location known'))
4617
5317
b_other = Branch.open(location)
4618
5318
try:
4619
5319
b.bind(b_other)
4620
5320
except errors.DivergedBranches:
4621
raise errors.BzrCommandError('These branches have diverged.'
4622
' Try merging, and then bind again.')
5321
raise errors.BzrCommandError(gettext('These branches have diverged.'
5322
' Try merging, and then bind again.'))
4623
5323
if b.get_config().has_explicit_nickname():
4624
5324
b.nick = b_other.nick
4625
5325
4626
5326
4627
5327
class cmd_unbind(Command):
4628
"""Convert the current checkout into a regular branch.
5328
__doc__ = """Convert the current checkout into a regular branch.
4629
5329
4630
5330
After unbinding, the local branch is considered independent and subsequent
4631
5331
commits will be local only.
4633
5333
4634
5334
_see_also = ['checkouts', 'bind']
4635
5335
takes_args = []
4636
takes_options = []
5336
takes_options = ['directory']
4637
5337
4638
def run(self):
4639
b, relpath = Branch.open_containing(u'.')
5338
def run(self, directory=u'.'):
5339
b, relpath = Branch.open_containing(directory)
4640
5340
if not b.unbind():
4641
raise errors.BzrCommandError('Local branch is not bound')
5341
raise errors.BzrCommandError(gettext('Local branch is not bound'))
4642
5342
4643
5343
4644
5344
class cmd_uncommit(Command):
4645
"""Remove the last committed revision.
5345
__doc__ = """Remove the last committed revision.
4646
5346
4647
5347
--verbose will print out what is being removed.
4648
5348
--dry-run will go through all the motions, but not actually
4665
5365
takes_options = ['verbose', 'revision',
4666
5366
Option('dry-run', help='Don\'t actually make changes.'),
4667
5367
Option('force', help='Say yes to all questions.'),
5368
Option('keep-tags',
5369
help='Keep tags that point to removed revisions.'),
4668
5370
Option('local',
4669
5371
help="Only remove the commits from the local branch"
4670
5372
" when in a checkout."
4674
5376
aliases = []
4675
5377
encoding_type = 'replace'
4676
5378
4677
def run(self, location=None,
4678
dry_run=False, verbose=False,
4679
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):
4680
5381
if location is None:
4681
5382
location = u'.'
4682
control, relpath = bzrdir.BzrDir.open_containing(location)
5383
control, relpath = controldir.ControlDir.open_containing(location)
4683
5384
try:
4684
5385
tree = control.open_workingtree()
4685
5386
b = tree.branch
4688
5389
b = control.open_branch()
4689
5390
4690
5391
if tree is not None:
4691
tree.lock_write()
4692
self.add_cleanup(tree.unlock)
5392
self.add_cleanup(tree.lock_write().unlock)
4693
5393
else:
4694
b.lock_write()
4695
self.add_cleanup(b.unlock)
4696
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)
4697
5397
4698
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):
4699
5400
from bzrlib.log import log_formatter, show_log
4700
5401
from bzrlib.uncommit import uncommit
4701
5402
4716
5417
rev_id = b.get_rev_id(revno)
4717
5418
4718
5419
if rev_id is None or _mod_revision.is_null(rev_id):
4719
self.outf.write('No revisions to uncommit.\n')
5420
self.outf.write(gettext('No revisions to uncommit.\n'))
4720
5421
return 1
4721
5422
4722
5423
lf = log_formatter('short',
4731
5432
end_revision=last_revno)
4732
5433
4733
5434
if dry_run:
4734
print 'Dry-run, pretending to remove the above revisions.'
4735
if not force:
4736
val = raw_input('Press <enter> to continue')
5435
self.outf.write(gettext('Dry-run, pretending to remove'
5436
' the above revisions.\n'))
4737
5437
else:
4738
print 'The above revision(s) will be removed.'
4739
if not force:
4740
val = raw_input('Are you sure [y/N]? ')
4741
if val.lower() not in ('y', 'yes'):
4742
print 'Canceled'
4743
return 0
5438
self.outf.write(gettext('The above revision(s) will be removed.\n'))
5439
5440
if not force:
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'))
5446
return 0
4744
5447
4745
5448
mutter('Uncommitting from {%s} to {%s}',
4746
5449
last_rev_id, rev_id)
4747
5450
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4748
revno=revno, local=local)
4749
note('You can restore the old tip by running:\n'
4750
' bzr pull . -r revid:%s', 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)
4751
5454
4752
5455
4753
5456
class cmd_break_lock(Command):
4754
"""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.
4755
5461
4756
5462
CAUTION: Locks should only be broken when you are sure that the process
4757
5463
holding the lock has been stopped.
4762
5468
:Examples:
4763
5469
bzr break-lock
4764
5470
bzr break-lock bzr+ssh://example.com/bzr/foo
5471
bzr break-lock --conf ~/.bazaar
4765
5472
"""
5473
4766
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
]
4767
5481
4768
def run(self, location=None, show=False):
5482
def run(self, location=None, config=False, force=False):
4769
5483
if location is None:
4770
5484
location = u'.'
4771
control, relpath = bzrdir.BzrDir.open_containing(location)
4772
try:
4773
control.break_lock()
4774
except NotImplementedError:
4775
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
4776
5498
4777
5499
4778
5500
class cmd_wait_until_signalled(Command):
4779
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
5501
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4780
5502
4781
5503
This just prints a line to signal when it is ready, then blocks on stdin.
4782
5504
"""
4790
5512
4791
5513
4792
5514
class cmd_serve(Command):
4793
"""Run the bzr server."""
5515
__doc__ = """Run the bzr server."""
4794
5516
4795
5517
aliases = ['server']
4796
5518
4801
5523
help="Protocol to serve.",
4802
5524
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4803
5525
value_switches=True),
5526
Option('listen',
5527
help='Listen for connections on nominated address.', type=str),
4804
5528
Option('port',
4805
help='Listen for connections on nominated port of the form '
4806
'[hostname:]portnumber. Passing 0 as the port number will '
4807
'result in a dynamically allocated port. The default port '
4808
'depends on the protocol.',
4809
type=str),
4810
Option('directory',
4811
help='Serve contents of this directory.',
4812
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.'),
4813
5535
Option('allow-writes',
4814
5536
help='By default the server is a readonly server. Supplying '
4815
5537
'--allow-writes enables write access to the contents of '
4819
5541
'option leads to global uncontrolled write access to your '
4820
5542
'file system.'
4821
5543
),
5544
Option('client-timeout', type=float,
5545
help='Override the default idle client timeout (5min).'),
4822
5546
]
4823
5547
4824
def get_host_and_port(self, port):
4825
"""Return the host and port to run the smart server on.
4826
4827
If 'port' is None, None will be returned for the host and port.
4828
4829
If 'port' has a colon in it, the string before the colon will be
4830
interpreted as the host.
4831
4832
:param port: A string of the port to run the server on.
4833
:return: A tuple of (host, port), where 'host' is a host name or IP,
4834
and port is an integer TCP/IP port.
4835
"""
4836
host = None
4837
if port is not None:
4838
if ':' in port:
4839
host, port = port.split(':')
4840
port = int(port)
4841
return host, port
4842
4843
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4844
protocol=None):
4845
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
4846
5551
if directory is None:
4847
5552
directory = os.getcwd()
4848
5553
if protocol is None:
4849
protocol = transport_server_registry.get()
4850
host, port = self.get_host_and_port(port)
4851
url = urlutils.local_path_to_url(directory)
5554
protocol = transport.transport_server_registry.get()
5555
url = transport.location_to_url(directory)
4852
5556
if not allow_writes:
4853
5557
url = 'readonly+' + url
4854
transport = get_transport(url)
4855
protocol(transport, host, port, inet)
5558
t = transport.get_transport_from_url(url)
5559
protocol(t, listen, port, inet, client_timeout)
4856
5560
4857
5561
4858
5562
class cmd_join(Command):
4859
"""Combine a tree into its containing tree.
5563
__doc__ = """Combine a tree into its containing tree.
4860
5564
4861
5565
This command requires the target tree to be in a rich-root format.
4862
5566
4864
5568
not part of it. (Such trees can be produced by "bzr split", but also by
4865
5569
running "bzr branch" with the target inside a tree.)
4866
5570
4867
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
4868
5572
part. This is marked as a merge of the subtree into the containing tree,
4869
5573
and all history is preserved.
4870
5574
"""
4881
5585
containing_tree = WorkingTree.open_containing(parent_dir)[0]
4882
5586
repo = containing_tree.branch.repository
4883
5587
if not repo.supports_rich_root():
4884
raise errors.BzrCommandError(
5588
raise errors.BzrCommandError(gettext(
4885
5589
"Can't join trees because %s doesn't support rich root data.\n"
4886
"You can use bzr upgrade on the repository."
5590
"You can use bzr upgrade on the repository.")
4887
5591
% (repo,))
4888
5592
if reference:
4889
5593
try:
4891
5595
except errors.BadReferenceTarget, e:
4892
5596
# XXX: Would be better to just raise a nicely printable
4893
5597
# exception from the real origin. Also below. mbp 20070306
4894
raise errors.BzrCommandError("Cannot join %s. %s" %
4895
(tree, e.reason))
5598
raise errors.BzrCommandError(
5599
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4896
5600
else:
4897
5601
try:
4898
5602
containing_tree.subsume(sub_tree)
4899
5603
except errors.BadSubsumeSource, e:
4900
raise errors.BzrCommandError("Cannot join %s. %s" %
4901
(tree, e.reason))
5604
raise errors.BzrCommandError(
5605
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4902
5606
4903
5607
4904
5608
class cmd_split(Command):
4905
"""Split a subdirectory of a tree into a separate tree.
5609
__doc__ = """Split a subdirectory of a tree into a separate tree.
4906
5610
4907
5611
This command will produce a target tree in a format that supports
4908
5612
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4928
5632
4929
5633
4930
5634
class cmd_merge_directive(Command):
4931
"""Generate a merge directive for auto-merge tools.
5635
__doc__ = """Generate a merge directive for auto-merge tools.
4932
5636
4933
5637
A directive requests a merge to be performed, and also provides all the
4934
5638
information necessary to do so. This means it must either include a
4951
5655
_see_also = ['send']
4952
5656
4953
5657
takes_options = [
5658
'directory',
4954
5659
RegistryOption.from_kwargs('patch-type',
4955
5660
'The type of patch to include in the directive.',
4956
5661
title='Patch type',
4969
5674
encoding_type = 'exact'
4970
5675
4971
5676
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4972
sign=False, revision=None, mail_to=None, message=None):
5677
sign=False, revision=None, mail_to=None, message=None,
5678
directory=u'.'):
4973
5679
from bzrlib.revision import ensure_null, NULL_REVISION
4974
5680
include_patch, include_bundle = {
4975
5681
'plain': (False, False),
4976
5682
'diff': (True, False),
4977
5683
'bundle': (True, True),
4978
5684
}[patch_type]
4979
branch = Branch.open('.')
5685
branch = Branch.open(directory)
4980
5686
stored_submit_branch = branch.get_submit_branch()
4981
5687
if submit_branch is None:
4982
5688
submit_branch = stored_submit_branch
4986
5692
if submit_branch is None:
4987
5693
submit_branch = branch.get_parent()
4988
5694
if submit_branch is None:
4989
raise errors.BzrCommandError('No submit branch specified or known')
5695
raise errors.BzrCommandError(gettext('No submit branch specified or known'))
4990
5696
4991
5697
stored_public_branch = branch.get_public_branch()
4992
5698
if public_branch is None:
4993
5699
public_branch = stored_public_branch
4994
5700
elif stored_public_branch is None:
5701
# FIXME: Should be done only if we succeed ? -- vila 2012-01-03
4995
5702
branch.set_public_branch(public_branch)
4996
5703
if not include_bundle and public_branch is None:
4997
raise errors.BzrCommandError('No public branch specified or'
4998
' known')
5704
raise errors.BzrCommandError(gettext('No public branch specified or'
5705
' known'))
4999
5706
base_revision_id = None
5000
5707
if revision is not None:
5001
5708
if len(revision) > 2:
5002
raise errors.BzrCommandError('bzr merge-directive takes '
5003
'at most two one revision identifiers')
5709
raise errors.BzrCommandError(gettext('bzr merge-directive takes '
5710
'at most two one revision identifiers'))
5004
5711
revision_id = revision[-1].as_revision_id(branch)
5005
5712
if len(revision) == 2:
5006
5713
base_revision_id = revision[0].as_revision_id(branch)
5008
5715
revision_id = branch.last_revision()
5009
5716
revision_id = ensure_null(revision_id)
5010
5717
if revision_id == NULL_REVISION:
5011
raise errors.BzrCommandError('No revisions to bundle.')
5718
raise errors.BzrCommandError(gettext('No revisions to bundle.'))
5012
5719
directive = merge_directive.MergeDirective2.from_objects(
5013
5720
branch.repository, revision_id, time.time(),
5014
5721
osutils.local_time_offset(), submit_branch,
5022
5729
self.outf.writelines(directive.to_lines())
5023
5730
else:
5024
5731
message = directive.to_email(mail_to, branch, sign)
5025
s = SMTPConnection(branch.get_config())
5732
s = SMTPConnection(branch.get_config_stack())
5026
5733
s.send_email(message)
5027
5734
5028
5735
5029
5736
class cmd_send(Command):
5030
"""Mail or create a merge-directive for submitting changes.
5737
__doc__ = """Mail or create a merge-directive for submitting changes.
5031
5738
5032
5739
A merge directive provides many things needed for requesting merges:
5033
5740
5058
5765
source branch defaults to that containing the working directory, but can
5059
5766
be changed using --from.
5060
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
5061
5774
In order to calculate those changes, bzr must analyse the submit branch.
5062
5775
Therefore it is most efficient for the submit branch to be a local mirror.
5063
5776
If a public location is known for the submit_branch, that location is used
5067
5780
given, in which case it is sent to a file.
5068
5781
5069
5782
Mail is sent using your preferred mail program. This should be transparent
5070
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.
5071
5784
If the preferred client can't be found (or used), your editor will be used.
5072
5785
5073
5786
To use a specific mail program, set the mail_client configuration option.
5115
5828
short_name='f',
5116
5829
type=unicode),
5117
5830
Option('output', short_name='o',
5118
help='Write merge directive to this file; '
5831
help='Write merge directive to this file or directory; '
5119
5832
'use - for stdout.',
5120
5833
type=unicode),
5121
5834
Option('strict',
5132
5845
]
5133
5846
5134
5847
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5135
no_patch=False, revision=None, remember=False, output=None,
5848
no_patch=False, revision=None, remember=None, output=None,
5136
5849
format=None, mail_to=None, message=None, body=None,
5137
5850
strict=None, **kwargs):
5138
5851
from bzrlib.send import send
5144
5857
5145
5858
5146
5859
class cmd_bundle_revisions(cmd_send):
5147
"""Create a merge-directive for submitting changes.
5860
__doc__ = """Create a merge-directive for submitting changes.
5148
5861
5149
5862
A merge directive provides many things needed for requesting merges:
5150
5863
5217
5930
5218
5931
5219
5932
class cmd_tag(Command):
5220
"""Create, remove or modify a tag naming a revision.
5933
__doc__ = """Create, remove or modify a tag naming a revision.
5221
5934
5222
5935
Tags give human-meaningful names to revisions. Commands that take a -r
5223
5936
(--revision) option can be given -rtag:X, where X is any previously
5231
5944
5232
5945
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5233
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.
5234
5952
"""
5235
5953
5236
5954
_see_also = ['commit', 'tags']
5237
takes_args = ['tag_name']
5955
takes_args = ['tag_name?']
5238
5956
takes_options = [
5239
5957
Option('delete',
5240
5958
help='Delete this tag rather than placing it.',
5241
5959
),
5242
Option('directory',
5243
help='Branch in which to place the tag.',
5244
short_name='d',
5245
type=unicode,
5246
),
5960
custom_help('directory',
5961
help='Branch in which to place the tag.'),
5247
5962
Option('force',
5248
5963
help='Replace existing tags.',
5249
5964
),
5250
5965
'revision',
5251
5966
]
5252
5967
5253
def run(self, tag_name,
5968
def run(self, tag_name=None,
5254
5969
delete=None,
5255
5970
directory='.',
5256
5971
force=None,
5257
5972
revision=None,
5258
5973
):
5259
5974
branch, relpath = Branch.open_containing(directory)
5260
branch.lock_write()
5261
self.add_cleanup(branch.unlock)
5975
self.add_cleanup(branch.lock_write().unlock)
5262
5976
if delete:
5977
if tag_name is None:
5978
raise errors.BzrCommandError(gettext("No tag specified to delete."))
5263
5979
branch.tags.delete_tag(tag_name)
5264
self.outf.write('Deleted tag %s.\n' % tag_name)
5980
note(gettext('Deleted tag %s.') % tag_name)
5265
5981
else:
5266
5982
if revision:
5267
5983
if len(revision) != 1:
5268
raise errors.BzrCommandError(
5984
raise errors.BzrCommandError(gettext(
5269
5985
"Tags can only be placed on a single revision, "
5270
"not on a range")
5986
"not on a range"))
5271
5987
revision_id = revision[0].as_revision_id(branch)
5272
5988
else:
5273
5989
revision_id = branch.last_revision()
5274
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):
5275
6000
raise errors.TagAlreadyExists(tag_name)
5276
branch.tags.set_tag(tag_name, revision_id)
5277
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)
5278
6009
5279
6010
5280
6011
class cmd_tags(Command):
5281
"""List tags.
6012
__doc__ = """List tags.
5282
6013
5283
6014
This command shows a table of tag names and the revisions they reference.
5284
6015
"""
5285
6016
5286
6017
_see_also = ['tag']
5287
6018
takes_options = [
5288
Option('directory',
5289
help='Branch whose tags should be displayed.',
5290
short_name='d',
5291
type=unicode,
5292
),
5293
RegistryOption.from_kwargs('sort',
6019
custom_help('directory',
6020
help='Branch whose tags should be displayed.'),
6021
RegistryOption('sort',
5294
6022
'Sort tags by different criteria.', title='Sorting',
5295
alpha='Sort tags lexicographically (default).',
5296
time='Sort tags chronologically.',
6023
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5297
6024
),
5298
6025
'show-ids',
5299
6026
'revision',
5300
6027
]
5301
6028
5302
6029
@display_command
5303
def run(self,
5304
directory='.',
5305
sort='alpha',
5306
show_ids=False,
5307
revision=None,
5308
):
6030
def run(self, directory='.', sort=None, show_ids=False, revision=None):
6031
from bzrlib.tag import tag_sort_methods
5309
6032
branch, relpath = Branch.open_containing(directory)
5310
6033
5311
6034
tags = branch.tags.get_tag_dict().items()
5312
6035
if not tags:
5313
6036
return
5314
6037
5315
branch.lock_read()
5316
self.add_cleanup(branch.unlock)
6038
self.add_cleanup(branch.lock_read().unlock)
5317
6039
if revision:
5318
graph = branch.repository.get_graph()
5319
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5320
revid1, revid2 = rev1.rev_id, rev2.rev_id
5321
# only show revisions between revid1 and revid2 (inclusive)
5322
tags = [(tag, revid) for tag, revid in tags if
5323
graph.is_between(revid, revid1, revid2)]
5324
if sort == 'alpha':
5325
tags.sort()
5326
elif sort == 'time':
5327
timestamps = {}
5328
for tag, revid in tags:
5329
try:
5330
revobj = branch.repository.get_revision(revid)
5331
except errors.NoSuchRevision:
5332
timestamp = sys.maxint # place them at the end
5333
else:
5334
timestamp = revobj.timestamp
5335
timestamps[revid] = timestamp
5336
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)
5337
6045
if not show_ids:
5338
6046
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5339
6047
for index, (tag, revid) in enumerate(tags):
5341
6049
revno = branch.revision_id_to_dotted_revno(revid)
5342
6050
if isinstance(revno, tuple):
5343
6051
revno = '.'.join(map(str, revno))
5344
except errors.NoSuchRevision:
6052
except (errors.NoSuchRevision,
6053
errors.GhostRevisionsHaveNoRevno,
6054
errors.UnsupportedOperation):
5345
6055
# Bad tag data/merges can lead to tagged revisions
5346
6056
# which are not in this branch. Fail gracefully ...
5347
6057
revno = '?'
5350
6060
for tag, revspec in tags:
5351
6061
self.outf.write('%-20s %s\n' % (tag, revspec))
5352
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
5353
6089
5354
6090
class cmd_reconfigure(Command):
5355
"""Reconfigure the type of a bzr directory.
6091
__doc__ = """Reconfigure the type of a bzr directory.
5356
6092
5357
6093
A target configuration must be specified.
5358
6094
5369
6105
takes_args = ['location?']
5370
6106
takes_options = [
5371
6107
RegistryOption.from_kwargs(
5372
'target_type',
5373
title='Target type',
5374
help='The type to reconfigure the directory to.',
6108
'tree_type',
6109
title='Tree type',
6110
help='The relation between branch and tree.',
5375
6111
value_switches=True, enum_switch=False,
5376
6112
branch='Reconfigure to be an unbound branch with no working tree.',
5377
6113
tree='Reconfigure to be an unbound branch with a working tree.',
5378
6114
checkout='Reconfigure to be a bound branch with a working tree.',
5379
6115
lightweight_checkout='Reconfigure to be a lightweight'
5380
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,
5381
6123
standalone='Reconfigure to be a standalone branch '
5382
6124
'(i.e. stop using shared repository).',
5383
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,
5384
6132
with_trees='Reconfigure repository to create '
5385
6133
'working trees on branches by default.',
5386
6134
with_no_trees='Reconfigure repository to not create '
5400
6148
),
5401
6149
]
5402
6150
5403
def run(self, location=None, target_type=None, bind_to=None, force=False,
5404
stacked_on=None,
5405
unstacked=None):
5406
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)
5407
6155
if stacked_on and unstacked:
5408
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
6156
raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5409
6157
elif stacked_on is not None:
5410
6158
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5411
6159
elif unstacked:
5413
6161
# At the moment you can use --stacked-on and a different
5414
6162
# reconfiguration shape at the same time; there seems no good reason
5415
6163
# to ban it.
5416
if target_type is None:
6164
if (tree_type is None and
6165
repository_type is None and
6166
repository_trees is None):
5417
6167
if stacked_on or unstacked:
5418
6168
return
5419
6169
else:
5420
raise errors.BzrCommandError('No target configuration '
5421
'specified')
5422
elif target_type == 'branch':
6170
raise errors.BzrCommandError(gettext('No target configuration '
6171
'specified'))
6172
reconfiguration = None
6173
if tree_type == 'branch':
5423
6174
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5424
elif target_type == 'tree':
6175
elif tree_type == 'tree':
5425
6176
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5426
elif target_type == 'checkout':
6177
elif tree_type == 'checkout':
5427
6178
reconfiguration = reconfigure.Reconfigure.to_checkout(
5428
6179
directory, bind_to)
5429
elif target_type == 'lightweight-checkout':
6180
elif tree_type == 'lightweight-checkout':
5430
6181
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5431
6182
directory, bind_to)
5432
elif target_type == 'use-shared':
6183
if reconfiguration:
6184
reconfiguration.apply(force)
6185
reconfiguration = None
6186
if repository_type == 'use-shared':
5433
6187
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5434
elif target_type == 'standalone':
6188
elif repository_type == 'standalone':
5435
6189
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5436
elif target_type == 'with-trees':
6190
if reconfiguration:
6191
reconfiguration.apply(force)
6192
reconfiguration = None
6193
if repository_trees == 'with-trees':
5437
6194
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5438
6195
directory, True)
5439
elif target_type == 'with-no-trees':
6196
elif repository_trees == 'with-no-trees':
5440
6197
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5441
6198
directory, False)
5442
reconfiguration.apply(force)
6199
if reconfiguration:
6200
reconfiguration.apply(force)
6201
reconfiguration = None
5443
6202
5444
6203
5445
6204
class cmd_switch(Command):
5446
"""Set the branch of a checkout and update.
6205
__doc__ = """Set the branch of a checkout and update.
5447
6206
5448
6207
For lightweight checkouts, this changes the branch being referenced.
5449
6208
For heavyweight checkouts, this checks that there are no local commits
5466
6225
"""
5467
6226
5468
6227
takes_args = ['to_location?']
5469
takes_options = [Option('force',
6228
takes_options = ['directory',
6229
Option('force',
5470
6230
help='Switch even if local commits will be lost.'),
5471
6231
'revision',
5472
6232
Option('create-branch', short_name='b',
5473
6233
help='Create the target branch from this one before'
5474
6234
' switching to it.'),
6235
Option('store',
6236
help='Store and restore uncommitted changes in the'
6237
' branch.'),
5475
6238
]
5476
6239
5477
6240
def run(self, to_location=None, force=False, create_branch=False,
5478
revision=None):
6241
revision=None, directory=u'.', store=False):
5479
6242
from bzrlib import switch
5480
tree_location = '.'
6243
tree_location = directory
5481
6244
revision = _get_one_revision('switch', revision)
5482
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]
5483
6248
if to_location is None:
5484
6249
if revision is None:
5485
raise errors.BzrCommandError('You must supply either a'
5486
' revision or a location')
5487
to_location = '.'
6250
raise errors.BzrCommandError(gettext('You must supply either a'
6251
' revision or a location'))
6252
to_location = tree_location
5488
6253
try:
5489
branch = control_dir.open_branch()
6254
branch = control_dir.open_branch(
6255
possible_transports=possible_transports)
5490
6256
had_explicit_nick = branch.get_config().has_explicit_nickname()
5491
6257
except errors.NotBranchError:
5492
6258
branch = None
5493
6259
had_explicit_nick = False
5494
6260
if create_branch:
5495
6261
if branch is None:
5496
raise errors.BzrCommandError('cannot create branch without'
5497
' source branch')
5498
to_location = directory_service.directories.dereference(
5499
to_location)
5500
if '/' not in to_location and '\\' not in to_location:
5501
# This path is meant to be relative to the existing branch
5502
this_url = self._get_branch_location(control_dir)
5503
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)
5504
6266
to_branch = branch.bzrdir.sprout(to_location,
5505
possible_transports=[branch.bzrdir.root_transport],
5506
source_branch=branch).open_branch()
6267
possible_transports=possible_transports,
6268
source_branch=branch).open_branch()
5507
6269
else:
5508
6270
try:
5509
to_branch = Branch.open(to_location)
6271
to_branch = Branch.open(to_location,
6272
possible_transports=possible_transports)
5510
6273
except errors.NotBranchError:
5511
this_url = self._get_branch_location(control_dir)
5512
to_branch = Branch.open(
5513
urlutils.join(this_url, '..', to_location))
6274
to_branch = open_sibling_branch(control_dir, to_location,
6275
possible_transports=possible_transports)
5514
6276
if revision is not None:
5515
6277
revision = revision.as_revision_id(to_branch)
5516
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)
5517
6280
if had_explicit_nick:
5518
6281
branch = control_dir.open_branch() #get the new branch!
5519
6282
branch.nick = to_branch.nick
5520
note('Switched to branch: %s',
6283
note(gettext('Switched to branch: %s'),
5521
6284
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5522
6285
5523
def _get_branch_location(self, control_dir):
5524
"""Return location of branch for this control dir."""
5525
try:
5526
this_branch = control_dir.open_branch()
5527
# This may be a heavy checkout, where we want the master branch
5528
master_location = this_branch.get_bound_location()
5529
if master_location is not None:
5530
return master_location
5531
# If not, use a local sibling
5532
return this_branch.base
5533
except errors.NotBranchError:
5534
format = control_dir.find_branch_format()
5535
if getattr(format, 'get_reference', None) is not None:
5536
return format.get_reference(control_dir)
5537
else:
5538
return control_dir.root_transport.base
5539
6286
5540
6287
5541
6288
class cmd_view(Command):
5542
"""Manage filtered views.
6289
__doc__ = """Manage filtered views.
5543
6290
5544
6291
Views provide a mask over the tree so that users can focus on
5545
6292
a subset of a tree when doing their work. After creating a view,
5625
6372
name=None,
5626
6373
switch=None,
5627
6374
):
5628
tree, file_list = tree_files(file_list, apply_view=False)
6375
tree, file_list = WorkingTree.open_containing_paths(file_list,
6376
apply_view=False)
5629
6377
current_view, view_dict = tree.views.get_view_info()
5630
6378
if name is None:
5631
6379
name = current_view
5632
6380
if delete:
5633
6381
if file_list:
5634
raise errors.BzrCommandError(
5635
"Both --delete and a file list specified")
6382
raise errors.BzrCommandError(gettext(
6383
"Both --delete and a file list specified"))
5636
6384
elif switch:
5637
raise errors.BzrCommandError(
5638
"Both --delete and --switch specified")
6385
raise errors.BzrCommandError(gettext(
6386
"Both --delete and --switch specified"))
5639
6387
elif all:
5640
6388
tree.views.set_view_info(None, {})
5641
self.outf.write("Deleted all views.\n")
6389
self.outf.write(gettext("Deleted all views.\n"))
5642
6390
elif name is None:
5643
raise errors.BzrCommandError("No current view to delete")
6391
raise errors.BzrCommandError(gettext("No current view to delete"))
5644
6392
else:
5645
6393
tree.views.delete_view(name)
5646
self.outf.write("Deleted '%s' view.\n" % name)
6394
self.outf.write(gettext("Deleted '%s' view.\n") % name)
5647
6395
elif switch:
5648
6396
if file_list:
5649
raise errors.BzrCommandError(
5650
"Both --switch and a file list specified")
6397
raise errors.BzrCommandError(gettext(
6398
"Both --switch and a file list specified"))
5651
6399
elif all:
5652
raise errors.BzrCommandError(
5653
"Both --switch and --all specified")
6400
raise errors.BzrCommandError(gettext(
6401
"Both --switch and --all specified"))
5654
6402
elif switch == 'off':
5655
6403
if current_view is None:
5656
raise errors.BzrCommandError("No current view to disable")
6404
raise errors.BzrCommandError(gettext("No current view to disable"))
5657
6405
tree.views.set_view_info(None, view_dict)
5658
self.outf.write("Disabled '%s' view.\n" % (current_view))
6406
self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5659
6407
else:
5660
6408
tree.views.set_view_info(switch, view_dict)
5661
6409
view_str = views.view_display_str(tree.views.lookup_view())
5662
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))
5663
6411
elif all:
5664
6412
if view_dict:
5665
self.outf.write('Views defined:\n')
6413
self.outf.write(gettext('Views defined:\n'))
5666
6414
for view in sorted(view_dict):
5667
6415
if view == current_view:
5668
6416
active = "=>"
5671
6419
view_str = views.view_display_str(view_dict[view])
5672
6420
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5673
6421
else:
5674
self.outf.write('No views defined.\n')
6422
self.outf.write(gettext('No views defined.\n'))
5675
6423
elif file_list:
5676
6424
if name is None:
5677
6425
# No name given and no current view set
5678
6426
name = 'my'
5679
6427
elif name == 'off':
5680
raise errors.BzrCommandError(
5681
"Cannot change the 'off' pseudo view")
6428
raise errors.BzrCommandError(gettext(
6429
"Cannot change the 'off' pseudo view"))
5682
6430
tree.views.set_view(name, sorted(file_list))
5683
6431
view_str = views.view_display_str(tree.views.lookup_view())
5684
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))
5685
6433
else:
5686
6434
# list the files
5687
6435
if name is None:
5688
6436
# No name given and no current view set
5689
self.outf.write('No current view.\n')
6437
self.outf.write(gettext('No current view.\n'))
5690
6438
else:
5691
6439
view_str = views.view_display_str(tree.views.lookup_view(name))
5692
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))
5693
6441
5694
6442
5695
6443
class cmd_hooks(Command):
5696
"""Show hooks."""
6444
__doc__ = """Show hooks."""
5697
6445
5698
6446
hidden = True
5699
6447
5709
6457
self.outf.write(" %s\n" %
5710
6458
(some_hooks.get_hook_name(hook),))
5711
6459
else:
5712
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)
5713
6496
5714
6497
5715
6498
class cmd_shelve(Command):
5716
"""Temporarily set aside some changes from the current tree.
6499
__doc__ = """Temporarily set aside some changes from the current tree.
5717
6500
5718
6501
Shelve allows you to temporarily put changes you've made "on the shelf",
5719
6502
ie. out of the way, until a later time when you can bring them back from
5735
6518
5736
6519
You can put multiple items on the shelf, and by default, 'unshelve' will
5737
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
5738
6533
"""
5739
6534
5740
6535
takes_args = ['file*']
5741
6536
5742
6537
takes_options = [
6538
'directory',
5743
6539
'revision',
5744
6540
Option('all', help='Shelve all changes.'),
5745
6541
'message',
5751
6547
Option('destroy',
5752
6548
help='Destroy removed changes instead of shelving them.'),
5753
6549
]
5754
_see_also = ['unshelve']
6550
_see_also = ['unshelve', 'configuration']
5755
6551
5756
6552
def run(self, revision=None, all=False, file_list=None, message=None,
5757
writer=None, list=False, destroy=False):
6553
writer=None, list=False, destroy=False, directory=None):
5758
6554
if list:
5759
return self.run_for_list()
6555
return self.run_for_list(directory=directory)
5760
6556
from bzrlib.shelf_ui import Shelver
5761
6557
if writer is None:
5762
6558
writer = bzrlib.option.diff_writer_registry.get()
5763
6559
try:
5764
6560
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5765
file_list, message, destroy=destroy)
6561
file_list, message, destroy=destroy, directory=directory)
5766
6562
try:
5767
6563
shelver.run()
5768
6564
finally:
5770
6566
except errors.UserAbort:
5771
6567
return 0
5772
6568
5773
def run_for_list(self):
5774
tree = WorkingTree.open_containing('.')[0]
5775
tree.lock_read()
5776
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)
5777
6574
manager = tree.get_shelf_manager()
5778
6575
shelves = manager.active_shelves()
5779
6576
if len(shelves) == 0:
5780
note('No shelved changes.')
6577
note(gettext('No shelved changes.'))
5781
6578
return 0
5782
6579
for shelf_id in reversed(shelves):
5783
6580
message = manager.get_metadata(shelf_id).get('message')
5788
6585
5789
6586
5790
6587
class cmd_unshelve(Command):
5791
"""Restore shelved changes.
6588
__doc__ = """Restore shelved changes.
5792
6589
5793
6590
By default, the most recently shelved changes are restored. However if you
5794
6591
specify a shelf by id those changes will be restored instead. This works
5797
6594
5798
6595
takes_args = ['shelf_id?']
5799
6596
takes_options = [
6597
'directory',
5800
6598
RegistryOption.from_kwargs(
5801
6599
'action', help="The action to perform.",
5802
6600
enum_switch=False, value_switches=True,
5810
6608
]
5811
6609
_see_also = ['shelve']
5812
6610
5813
def run(self, shelf_id=None, action='apply'):
6611
def run(self, shelf_id=None, action='apply', directory=u'.'):
5814
6612
from bzrlib.shelf_ui import Unshelver
5815
unshelver = Unshelver.from_args(shelf_id, action)
6613
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5816
6614
try:
5817
6615
unshelver.run()
5818
6616
finally:
5820
6618
5821
6619
5822
6620
class cmd_clean_tree(Command):
5823
"""Remove unwanted files from working tree.
6621
__doc__ = """Remove unwanted files from working tree.
5824
6622
5825
6623
By default, only unknown files, not ignored files, are deleted. Versioned
5826
6624
files are never deleted.
5834
6632
5835
6633
To check what clean-tree will do, use --dry-run.
5836
6634
"""
5837
takes_options = [Option('ignored', help='Delete all ignored files.'),
5838
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'
5839
6638
' backups, and failed selftest dirs.'),
5840
6639
Option('unknown',
5841
6640
help='Delete files unknown to bzr (default).'),
5843
6642
' deleting them.'),
5844
6643
Option('force', help='Do not prompt before deleting.')]
5845
6644
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5846
force=False):
6645
force=False, directory=u'.'):
5847
6646
from bzrlib.clean_tree import clean_tree
5848
6647
if not (unknown or ignored or detritus):
5849
6648
unknown = True
5850
6649
if dry_run:
5851
6650
force = True
5852
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5853
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)
5854
6653
5855
6654
5856
6655
class cmd_reference(Command):
5857
"""list, view and set branch locations for nested trees.
6656
__doc__ = """list, view and set branch locations for nested trees.
5858
6657
5859
6658
If no arguments are provided, lists the branch locations for nested trees.
5860
6659
If one argument is provided, display the branch location for that tree.
5870
6669
if path is not None:
5871
6670
branchdir = path
5872
6671
tree, branch, relpath =(
5873
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
6672
controldir.ControlDir.open_containing_tree_or_branch(branchdir))
5874
6673
if path is not None:
5875
6674
path = relpath
5876
6675
if tree is None:
5900
6699
self.outf.write('%s %s\n' % (path, location))
5901
6700
5902
6701
5903
# these get imported and then picked up by the scan for cmd_*
5904
# TODO: Some more consistent way to split command definitions across files;
5905
# we do need to load at least some information about them to know of
5906
# aliases. ideally we would avoid loading the implementation until the
5907
# details were needed.
5908
from bzrlib.cmd_version_info import cmd_version_info
5909
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5910
from bzrlib.bundle.commands import (
5911
cmd_bundle_info,
5912
)
5913
from bzrlib.foreign import cmd_dpush
5914
from bzrlib.sign_my_commits import cmd_sign_my_commits
5915
from bzrlib.weave_commands import cmd_versionedfile_list, \
5916
cmd_weave_plan_merge, cmd_weave_merge_text
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