« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 4634.136.1
- compare with another revision
- download diff
- download tarball
- view history from revision 4634.136.1
- Committer: Ian Clatworthy
- Date: 2010-02-19 07:13:45 UTC
- mfrom: (4634.135.1 news-template-524184)
- mto: (4634.134.2 2.0)
- mto: This revision was merged to the branch mainline in revision 5069.
- Revision ID: ian.clatworthy@canonical.com-20100219071345-44j6ovnkv6rv46ei
NEWS section template into a separate file
- files added:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- bzrlib/util/elementtree
- files removed:
- .testr.conf
- apport
- bzrlib/branchfmt
- bzrlib/help_topics/es
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/grep
- bzrlib/plugins/news_merge
- bzrlib/plugins/news_merge/tests
- 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_foreign_vcs
- bzrlib/tests/per_repository_vf
- bzrlib/tests/per_uifactory
- contrib/debian
- doc/en/whats-new
- po
- files renamed:
- doc/en/release-notes/bzr-2.3.txt => NEWS
- doc/en/release-notes/release-template.txt => NEWS-template.txt
- bzrlib/doc_generate/conf.py => bzrlib/doc_generate/sphinx_conf.py
- bzrlib/help_topics/en/conflict-types.txt => bzrlib/help_topics/en/conflicts.txt
- bzrlib/plugins/weave_fmt/repository.py => bzrlib/repofmt/weaverepo.py
- bzrlib/commit_signature_commands.py => bzrlib/sign_my_commits.py
- bzrlib/tests/per_controldir/ => bzrlib/tests/per_bzrdir/
- bzrlib/tests/per_controldir/test_controldir.py => bzrlib/tests/per_bzrdir/test_bzrdir.py
- bzrlib/tests/per_repository_vf/helpers.py => bzrlib/tests/per_repository/helpers.py
- bzrlib/tests/per_repository_vf/test__generate_text_key_index.py => bzrlib/tests/per_repository/test__generate_text_key_index.py
- bzrlib/tests/per_repository_vf/test_add_inventory_by_delta.py => bzrlib/tests/per_repository/test_add_inventory_by_delta.py
- bzrlib/tests/per_repository_vf/test_check_reconcile.py => bzrlib/tests/per_repository/test_check_reconcile.py
- bzrlib/tests/per_repository_vf/test_find_text_key_references.py => bzrlib/tests/per_repository/test_find_text_key_references.py
- bzrlib/tests/per_repository/test_locking.py => bzrlib/tests/per_repository/test_is_write_locked.py
- bzrlib/tests/per_repository_vf/test_merge_directive.py => bzrlib/tests/per_repository/test_merge_directive.py
- bzrlib/tests/test__bencode.py => bzrlib/tests/test_bencode.py
- bzrlib/plugins/weave_fmt/xml4.py => bzrlib/xml4.py
- bzrlib/help_topics/es/conflict-types.txt => doc/es/user-guide/resolving_conflicts.txt
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2005-2012 Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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
21
19
import os
22
20
23
import bzrlib.bzrdir
24
25
from bzrlib import lazy_import
26
lazy_import.lazy_import(globals(), """
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
27
24
import cStringIO
28
import errno
29
25
import sys
30
26
import time
31
27
34
30
bugtracker,
35
31
bundle,
36
32
btree_index,
37
controldir,
38
directory_service,
33
bzrdir,
39
34
delta,
40
config as _mod_config,
35
config,
41
36
errors,
42
37
globbing,
43
38
hooks,
48
43
reconfigure,
49
44
rename_map,
50
45
revision as _mod_revision,
51
static_tuple,
52
timestamp,
46
symbol_versioning,
53
47
transport,
54
48
ui,
55
49
urlutils,
56
50
views,
57
gpg,
58
51
)
59
52
from bzrlib.branch import Branch
60
53
from bzrlib.conflicts import ConflictList
61
from bzrlib.transport import memory
62
54
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
63
55
from bzrlib.smtp_connection import SMTPConnection
64
56
from bzrlib.workingtree import WorkingTree
65
from bzrlib.i18n import gettext, ngettext
66
57
""")
67
58
68
from bzrlib.commands import (
69
Command,
70
builtin_command_registry,
71
display_command,
72
)
59
from bzrlib.commands import Command, display_command
73
60
from bzrlib.option import (
74
61
ListOption,
75
62
Option,
78
65
_parse_revision_str,
79
66
)
80
67
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
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
68
69
70
def tree_files(file_list, default_branch=u'.', canonicalize=True,
71
apply_view=True):
72
try:
73
return internal_tree_files(file_list, default_branch, canonicalize,
74
apply_view)
75
except errors.FileInWrongBranch, e:
76
raise errors.BzrCommandError("%s is not in the same branch as %s" %
77
(e.path, file_list[0]))
221
78
222
79
223
80
def tree_files_for_add(file_list):
248
105
if view_files:
249
106
file_list = view_files
250
107
view_str = views.view_display_str(view_files)
251
note(gettext("Ignoring files outside view. View is %s") % view_str)
108
note("Ignoring files outside view. View is %s" % view_str)
252
109
return tree, file_list
253
110
254
111
256
113
if revisions is None:
257
114
return None
258
115
if len(revisions) != 1:
259
raise errors.BzrCommandError(gettext(
260
'bzr %s --revision takes exactly one revision identifier') % (
116
raise errors.BzrCommandError(
117
'bzr %s --revision takes exactly one revision identifier' % (
261
118
command_name,))
262
119
return revisions[0]
263
120
285
142
return rev_tree
286
143
287
144
145
# XXX: Bad function name; should possibly also be a class method of
146
# WorkingTree rather than a function.
147
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
148
apply_view=True):
149
"""Convert command-line paths to a WorkingTree and relative paths.
150
151
This is typically used for command-line processors that take one or
152
more filenames, and infer the workingtree that contains them.
153
154
The filenames given are not required to exist.
155
156
:param file_list: Filenames to convert.
157
158
:param default_branch: Fallback tree path to use if file_list is empty or
159
None.
160
161
:param apply_view: if True and a view is set, apply it or check that
162
specified files are within it
163
164
:return: workingtree, [relative_paths]
165
"""
166
if file_list is None or len(file_list) == 0:
167
tree = WorkingTree.open_containing(default_branch)[0]
168
if tree.supports_views() and apply_view:
169
view_files = tree.views.lookup_view()
170
if view_files:
171
file_list = view_files
172
view_str = views.view_display_str(view_files)
173
note("Ignoring files outside view. View is %s" % view_str)
174
return tree, file_list
175
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
176
return tree, safe_relpath_files(tree, file_list, canonicalize,
177
apply_view=apply_view)
178
179
180
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
181
"""Convert file_list into a list of relpaths in tree.
182
183
:param tree: A tree to operate on.
184
:param file_list: A list of user provided paths or None.
185
:param apply_view: if True and a view is set, apply it or check that
186
specified files are within it
187
:return: A list of relative paths.
188
:raises errors.PathNotChild: When a provided path is in a different tree
189
than tree.
190
"""
191
if file_list is None:
192
return None
193
if tree.supports_views() and apply_view:
194
view_files = tree.views.lookup_view()
195
else:
196
view_files = []
197
new_list = []
198
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
199
# doesn't - fix that up here before we enter the loop.
200
if canonicalize:
201
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
202
else:
203
fixer = tree.relpath
204
for filename in file_list:
205
try:
206
relpath = fixer(osutils.dereference_path(filename))
207
if view_files and not osutils.is_inside_any(view_files, relpath):
208
raise errors.FileOutsideView(filename, view_files)
209
new_list.append(relpath)
210
except errors.PathNotChild:
211
raise errors.FileInWrongBranch(tree.branch, filename)
212
return new_list
213
214
288
215
def _get_view_info_for_change_reporter(tree):
289
216
"""Get the view information from a tree for change reporting."""
290
217
view_info = None
297
224
return view_info
298
225
299
226
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
308
227
# TODO: Make sure no commands unconditionally use the working directory as a
309
228
# branch. If a filename argument is used, the first of them should be used to
310
229
# specify the branch. (Perhaps this can be factored out into some kind of
312
231
# opens the branch?)
313
232
314
233
class cmd_status(Command):
315
__doc__ = """Display status summary.
234
"""Display status summary.
316
235
317
236
This reports on versioned and unknown files, reporting them
318
237
grouped by state. Possible states are:
338
257
unknown
339
258
Not versioned and not matching an ignore pattern.
340
259
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.
345
346
260
To see ignored files use 'bzr ignored'. For details on the
347
261
changes to file texts, use 'bzr diff'.
348
262
360
274
To skip the display of pending merge information altogether, use
361
275
the no-pending option or specify a file/directory.
362
276
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'.
277
If a revision argument is given, the status is calculated against
278
that revision, or between two revisions if two are provided.
369
279
"""
370
280
371
# TODO: --no-recurse/-N, --recurse options
281
# TODO: --no-recurse, --recurse options
372
282
373
283
takes_args = ['file*']
374
284
takes_options = ['show-ids', 'revision', 'change', 'verbose',
378
288
short_name='V'),
379
289
Option('no-pending', help='Don\'t show pending merges.',
380
290
),
381
Option('no-classify',
382
help='Do not mark object type using indicator.',
383
),
384
291
]
385
292
aliases = ['st', 'stat']
386
293
389
296
390
297
@display_command
391
298
def run(self, show_ids=False, file_list=None, revision=None, short=False,
392
versioned=False, no_pending=False, verbose=False,
393
no_classify=False):
299
versioned=False, no_pending=False, verbose=False):
394
300
from bzrlib.status import show_tree_status
395
301
396
302
if revision and len(revision) > 2:
397
raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
398
' one or two revision specifiers'))
303
raise errors.BzrCommandError('bzr status --revision takes exactly'
304
' one or two revision specifiers')
399
305
400
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
306
tree, relfile_list = tree_files(file_list)
401
307
# Avoid asking for specific files when that is not needed.
402
308
if relfile_list == ['']:
403
309
relfile_list = None
410
316
show_tree_status(tree, show_ids=show_ids,
411
317
specific_files=relfile_list, revision=revision,
412
318
to_file=self.outf, short=short, versioned=versioned,
413
show_pending=(not no_pending), verbose=verbose,
414
classify=not no_classify)
319
show_pending=(not no_pending), verbose=verbose)
415
320
416
321
417
322
class cmd_cat_revision(Command):
418
__doc__ = """Write out metadata for a revision.
323
"""Write out metadata for a revision.
419
324
420
325
The revision to print can either be specified by a specific
421
326
revision identifier, or you can use --revision.
423
328
424
329
hidden = True
425
330
takes_args = ['revision_id?']
426
takes_options = ['directory', 'revision']
331
takes_options = ['revision']
427
332
# cat-revision is more for frontends so should be exact
428
333
encoding = 'strict'
429
334
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
438
335
@display_command
439
def run(self, revision_id=None, revision=None, directory=u'.'):
336
def run(self, revision_id=None, revision=None):
440
337
if revision_id is not None and revision is not None:
441
raise errors.BzrCommandError(gettext('You can only supply one of'
442
' revision_id or --revision'))
338
raise errors.BzrCommandError('You can only supply one of'
339
' revision_id or --revision')
443
340
if revision_id is None and revision is None:
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
341
raise errors.BzrCommandError('You must supply either'
342
' --revision or a revision_id')
343
b = WorkingTree.open_containing(u'.')[0].branch
344
345
# TODO: jam 20060112 should cat-revision always output utf-8?
346
if revision_id is not None:
347
revision_id = osutils.safe_revision_id(revision_id, warn=False)
348
try:
349
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
350
except errors.NoSuchRevision:
351
msg = "The repository %s contains no revision %s." % (b.repository.base,
352
revision_id)
353
raise errors.BzrCommandError(msg)
354
elif revision is not None:
355
for rev in revision:
356
if rev is None:
357
raise errors.BzrCommandError('You cannot specify a NULL'
358
' revision.')
359
rev_id = rev.as_revision_id(b)
360
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
361
475
362
476
363
class cmd_dump_btree(Command):
477
__doc__ = """Dump the contents of a btree index file to stdout.
364
"""Dump the contents of a btree index file to stdout.
478
365
479
366
PATH is a btree index file, it can be any URL. This includes things like
480
367
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
528
415
self.outf.write(page_bytes[:header_end])
529
416
page_bytes = data
530
417
self.outf.write('\nPage %d\n' % (page_idx,))
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')
418
decomp_bytes = zlib.decompress(page_bytes)
419
self.outf.write(decomp_bytes)
420
self.outf.write('\n')
537
421
538
422
def _dump_entries(self, trans, basename):
539
423
try:
547
431
for node in bt.iter_all_entries():
548
432
# Node is made up of:
549
433
# (index, key, value, [references])
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)
556
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
557
self.outf.write('%s\n' % (as_tuple,))
434
self.outf.write('%s\n' % (node[1:],))
558
435
559
436
560
437
class cmd_remove_tree(Command):
561
__doc__ = """Remove the working tree from a given branch/checkout.
438
"""Remove the working tree from a given branch/checkout.
562
439
563
440
Since a lightweight checkout is little more than a working tree
564
441
this will refuse to run against one.
566
443
To re-create the working tree, use "bzr checkout".
567
444
"""
568
445
_see_also = ['checkout', 'working-trees']
569
takes_args = ['location*']
446
takes_args = ['location?']
570
447
takes_options = [
571
448
Option('force',
572
449
help='Remove the working tree even if it has '
573
'uncommitted or shelved changes.'),
450
'uncommitted changes.'),
574
451
]
575
452
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)
453
def run(self, location='.', force=False):
454
d = bzrdir.BzrDir.open(location)
455
456
try:
457
working = d.open_workingtree()
458
except errors.NoWorkingTree:
459
raise errors.BzrCommandError("No working tree to remove")
460
except errors.NotLocalUrl:
461
raise errors.BzrCommandError("You cannot remove the working tree"
462
" of a remote path")
629
463
if not force:
630
try:
631
tree.check_state()
632
except errors.BzrError:
633
pass # There seems to be a real error here, so we'll reset
634
else:
635
# Refuse
636
raise errors.BzrCommandError(gettext(
637
'The tree does not appear to be corrupt. You probably'
638
' want "bzr revert" instead. Use "--force" if you are'
639
' sure you want to reset the working tree.'))
640
if revision is None:
641
revision_ids = None
642
else:
643
revision_ids = [r.as_revision_id(tree.branch) for r in revision]
644
try:
645
tree.reset_state(revision_ids)
646
except errors.BzrError, e:
647
if revision_ids is None:
648
extra = (gettext(', the header appears corrupt, try passing -r -1'
649
' to set the state to the last commit'))
650
else:
651
extra = ''
652
raise errors.BzrCommandError(gettext('failed to reset the tree state{0}').format(extra))
464
# XXX: What about pending merges ? -- vila 20090629
465
if working.has_changes(working.basis_tree()):
466
raise errors.UncommittedChanges(working)
467
468
working_path = working.bzrdir.root_transport.base
469
branch_path = working.branch.bzrdir.root_transport.base
470
if working_path != branch_path:
471
raise errors.BzrCommandError("You cannot remove the working tree"
472
" from a lightweight checkout")
473
474
d.destroy_workingtree()
653
475
654
476
655
477
class cmd_revno(Command):
656
__doc__ = """Show current revision number.
478
"""Show current revision number.
657
479
658
480
This is equal to the number of revisions on this branch.
659
481
"""
661
483
_see_also = ['info']
662
484
takes_args = ['location?']
663
485
takes_options = [
664
Option('tree', help='Show revno of working tree.'),
665
'revision',
486
Option('tree', help='Show revno of working tree'),
666
487
]
667
488
668
489
@display_command
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
490
def run(self, tree=False, location=u'.'):
674
491
if tree:
675
492
try:
676
493
wt = WorkingTree.open_containing(location)[0]
677
self.add_cleanup(wt.lock_read().unlock)
494
wt.lock_read()
678
495
except (errors.NoWorkingTree, errors.NotLocalUrl):
679
496
raise errors.NoWorkingTree(location)
680
b = wt.branch
681
revid = wt.last_revision()
497
try:
498
revid = wt.last_revision()
499
try:
500
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
501
except errors.NoSuchRevision:
502
revno_t = ('???',)
503
revno = ".".join(str(n) for n in revno_t)
504
finally:
505
wt.unlock()
682
506
else:
683
507
b = Branch.open_containing(location)[0]
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)
698
self.cleanup_now()
699
self.outf.write(revno + '\n')
508
b.lock_read()
509
try:
510
revno = b.revno()
511
finally:
512
b.unlock()
513
514
self.outf.write(str(revno) + '\n')
700
515
701
516
702
517
class cmd_revision_info(Command):
703
__doc__ = """Show revision number and revision id for a given revision identifier.
518
"""Show revision number and revision id for a given revision identifier.
704
519
"""
705
520
hidden = True
706
521
takes_args = ['revision_info*']
707
522
takes_options = [
708
523
'revision',
709
custom_help('directory',
524
Option('directory',
710
525
help='Branch to examine, '
711
'rather than the one containing the working directory.'),
712
Option('tree', help='Show revno of working tree.'),
526
'rather than the one containing the working directory.',
527
short_name='d',
528
type=unicode,
529
),
530
Option('tree', help='Show revno of working tree'),
713
531
]
714
532
715
533
@display_command
719
537
try:
720
538
wt = WorkingTree.open_containing(directory)[0]
721
539
b = wt.branch
722
self.add_cleanup(wt.lock_read().unlock)
540
wt.lock_read()
723
541
except (errors.NoWorkingTree, errors.NotLocalUrl):
724
542
wt = None
725
543
b = Branch.open_containing(directory)[0]
726
self.add_cleanup(b.lock_read().unlock)
727
revision_ids = []
728
if revision is not None:
729
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
730
if revision_info_list is not None:
731
for rev_str in revision_info_list:
732
rev_spec = RevisionSpec.from_string(rev_str)
733
revision_ids.append(rev_spec.as_revision_id(b))
734
# No arguments supplied, default to the last revision
735
if len(revision_ids) == 0:
736
if tree:
737
if wt is None:
738
raise errors.NoWorkingTree(directory)
739
revision_ids.append(wt.last_revision())
544
b.lock_read()
545
try:
546
revision_ids = []
547
if revision is not None:
548
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
549
if revision_info_list is not None:
550
for rev_str in revision_info_list:
551
rev_spec = RevisionSpec.from_string(rev_str)
552
revision_ids.append(rev_spec.as_revision_id(b))
553
# No arguments supplied, default to the last revision
554
if len(revision_ids) == 0:
555
if tree:
556
if wt is None:
557
raise errors.NoWorkingTree(directory)
558
revision_ids.append(wt.last_revision())
559
else:
560
revision_ids.append(b.last_revision())
561
562
revinfos = []
563
maxlen = 0
564
for revision_id in revision_ids:
565
try:
566
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
567
revno = '.'.join(str(i) for i in dotted_revno)
568
except errors.NoSuchRevision:
569
revno = '???'
570
maxlen = max(maxlen, len(revno))
571
revinfos.append([revno, revision_id])
572
finally:
573
if wt is None:
574
b.unlock()
740
575
else:
741
revision_ids.append(b.last_revision())
742
743
revinfos = []
744
maxlen = 0
745
for revision_id in revision_ids:
746
try:
747
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
748
revno = '.'.join(str(i) for i in dotted_revno)
749
except errors.NoSuchRevision:
750
revno = '???'
751
maxlen = max(maxlen, len(revno))
752
revinfos.append([revno, revision_id])
753
754
self.cleanup_now()
576
wt.unlock()
577
755
578
for ri in revinfos:
756
579
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
757
580
758
581
759
582
class cmd_add(Command):
760
__doc__ = """Add specified files or directories.
583
"""Add specified files or directories.
761
584
762
585
In non-recursive mode, all the named items are added, regardless
763
586
of whether they were previously ignored. A warning is given if
771
594
are added. This search proceeds recursively into versioned
772
595
directories. If no names are given '.' is assumed.
773
596
774
A warning will be printed when nested trees are encountered,
775
unless they are explicitly ignored.
776
777
597
Therefore simply saying 'bzr add' will version all files that
778
598
are currently unknown.
779
599
795
615
796
616
Any files matching patterns in the ignore list will not be added
797
617
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.
802
618
"""
803
619
takes_args = ['file*']
804
620
takes_options = [
805
621
Option('no-recurse',
806
help="Don't recursively add the contents of directories.",
807
short_name='N'),
622
help="Don't recursively add the contents of directories."),
808
623
Option('dry-run',
809
624
help="Show what would be done, but don't actually do anything."),
810
625
'verbose',
832
647
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
833
648
to_file=self.outf, should_print=(not is_quiet()))
834
649
else:
835
action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
650
action = bzrlib.add.AddAction(to_file=self.outf,
836
651
should_print=(not is_quiet()))
837
652
838
653
if base_tree:
839
self.add_cleanup(base_tree.lock_read().unlock)
840
tree, file_list = tree_files_for_add(file_list)
841
added, ignored = tree.smart_add(file_list, not
842
no_recurse, action=action, save=not dry_run)
843
self.cleanup_now()
654
base_tree.lock_read()
655
try:
656
file_list = self._maybe_expand_globs(file_list)
657
tree, file_list = tree_files_for_add(file_list)
658
added, ignored = tree.smart_add(file_list, not
659
no_recurse, action=action, save=not dry_run)
660
finally:
661
if base_tree is not None:
662
base_tree.unlock()
844
663
if len(ignored) > 0:
845
664
if verbose:
846
665
for glob in sorted(ignored.keys()):
847
666
for path in ignored[glob]:
848
self.outf.write(
849
gettext("ignored {0} matching \"{1}\"\n").format(
850
path, glob))
667
self.outf.write("ignored %s matching \"%s\"\n"
668
% (path, glob))
851
669
852
670
853
671
class cmd_mkdir(Command):
854
__doc__ = """Create a new versioned directory.
672
"""Create a new versioned directory.
855
673
856
674
This is equivalent to creating the directory and then adding it.
857
675
"""
858
676
859
677
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
]
867
678
encoding_type = 'replace'
868
679
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)
680
def run(self, dir_list):
681
for d in dir_list:
682
os.mkdir(d)
683
wt, dd = WorkingTree.open_containing(d)
684
wt.add([dd])
685
self.outf.write('added %s\n' % d)
898
686
899
687
900
688
class cmd_relpath(Command):
901
__doc__ = """Show path of a file relative to root"""
689
"""Show path of a file relative to root"""
902
690
903
691
takes_args = ['filename']
904
692
hidden = True
913
701
914
702
915
703
class cmd_inventory(Command):
916
__doc__ = """Show inventory of the current working copy or a revision.
704
"""Show inventory of the current working copy or a revision.
917
705
918
706
It is possible to limit the output to a particular entry
919
707
type using the --kind option. For example: --kind file.
936
724
@display_command
937
725
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
938
726
if kind and kind not in ['file', 'directory', 'symlink']:
939
raise errors.BzrCommandError(gettext('invalid kind %r specified') % (kind,))
727
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
940
728
941
729
revision = _get_one_revision('inventory', revision)
942
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
943
self.add_cleanup(work_tree.lock_read().unlock)
944
if revision is not None:
945
tree = revision.as_tree(work_tree.branch)
946
947
extra_trees = [work_tree]
948
self.add_cleanup(tree.lock_read().unlock)
949
else:
950
tree = work_tree
951
extra_trees = []
952
953
self.add_cleanup(tree.lock_read().unlock)
954
if file_list is not None:
955
file_ids = tree.paths2ids(file_list, trees=extra_trees,
956
require_versioned=True)
957
# find_ids_across_trees may include some paths that don't
958
# exist in 'tree'.
959
entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
960
else:
961
entries = tree.iter_entries_by_dir()
962
963
for path, entry in sorted(entries):
730
work_tree, file_list = tree_files(file_list)
731
work_tree.lock_read()
732
try:
733
if revision is not None:
734
tree = revision.as_tree(work_tree.branch)
735
736
extra_trees = [work_tree]
737
tree.lock_read()
738
else:
739
tree = work_tree
740
extra_trees = []
741
742
if file_list is not None:
743
file_ids = tree.paths2ids(file_list, trees=extra_trees,
744
require_versioned=True)
745
# find_ids_across_trees may include some paths that don't
746
# exist in 'tree'.
747
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
748
for file_id in file_ids if file_id in tree)
749
else:
750
entries = tree.inventory.entries()
751
finally:
752
tree.unlock()
753
if tree is not work_tree:
754
work_tree.unlock()
755
756
for path, entry in entries:
964
757
if kind and kind != entry.kind:
965
758
continue
966
if path == "":
967
continue
968
759
if show_ids:
969
760
self.outf.write('%-50s %s\n' % (path, entry.file_id))
970
761
else:
973
764
974
765
975
766
class cmd_mv(Command):
976
__doc__ = """Move or rename a file.
767
"""Move or rename a file.
977
768
978
769
:Usage:
979
770
bzr mv OLDNAME NEWNAME
1006
797
if auto:
1007
798
return self.run_auto(names_list, after, dry_run)
1008
799
elif dry_run:
1009
raise errors.BzrCommandError(gettext('--dry-run requires --auto.'))
800
raise errors.BzrCommandError('--dry-run requires --auto.')
1010
801
if names_list is None:
1011
802
names_list = []
1012
803
if len(names_list) < 2:
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)
1019
self._run(tree, names_list, rel_names, after)
804
raise errors.BzrCommandError("missing file argument")
805
tree, rel_names = tree_files(names_list, canonicalize=False)
806
tree.lock_tree_write()
807
try:
808
self._run(tree, names_list, rel_names, after)
809
finally:
810
tree.unlock()
1020
811
1021
812
def run_auto(self, names_list, after, dry_run):
1022
813
if names_list is not None and len(names_list) > 1:
1023
raise errors.BzrCommandError(gettext('Only one path may be specified to'
1024
' --auto.'))
814
raise errors.BzrCommandError('Only one path may be specified to'
815
' --auto.')
1025
816
if after:
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)
1031
rename_map.RenameMap.guess_renames(work_tree, dry_run)
817
raise errors.BzrCommandError('--after cannot be specified with'
818
' --auto.')
819
work_tree, file_list = tree_files(names_list, default_branch='.')
820
work_tree.lock_tree_write()
821
try:
822
rename_map.RenameMap.guess_renames(work_tree, dry_run)
823
finally:
824
work_tree.unlock()
1032
825
1033
826
def _run(self, tree, names_list, rel_names, after):
1034
827
into_existing = osutils.isdir(names_list[-1])
1042
835
and rel_names[0].lower() == rel_names[1].lower()):
1043
836
into_existing = False
1044
837
else:
838
inv = tree.inventory
1045
839
# 'fix' the case of a potential 'from'
1046
840
from_id = tree.path2id(
1047
841
tree.get_canonical_inventory_path(rel_names[0]))
1048
842
if (not osutils.lexists(names_list[0]) and
1049
from_id and tree.stored_kind(from_id) == "directory"):
843
from_id and inv.get_file_kind(from_id) == "directory"):
1050
844
into_existing = False
1051
845
# move/rename
1052
846
if into_existing:
1054
848
# All entries reference existing inventory items, so fix them up
1055
849
# for cicp file-systems.
1056
850
rel_names = tree.get_canonical_inventory_paths(rel_names)
1057
for src, dest in tree.move(rel_names[:-1], rel_names[-1], after=after):
1058
if not is_quiet():
1059
self.outf.write("%s => %s\n" % (src, dest))
851
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
852
self.outf.write("%s => %s\n" % pair)
1060
853
else:
1061
854
if len(names_list) != 2:
1062
raise errors.BzrCommandError(gettext('to mv multiple files the'
855
raise errors.BzrCommandError('to mv multiple files the'
1063
856
' destination must be a versioned'
1064
' directory'))
857
' directory')
1065
858
1066
859
# for cicp file-systems: the src references an existing inventory
1067
860
# item:
1106
899
dest = osutils.pathjoin(dest_parent, dest_tail)
1107
900
mutter("attempting to move %s => %s", src, dest)
1108
901
tree.rename_one(src, dest, after=after)
1109
if not is_quiet():
1110
self.outf.write("%s => %s\n" % (src, dest))
902
self.outf.write("%s => %s\n" % (src, dest))
1111
903
1112
904
1113
905
class cmd_pull(Command):
1114
__doc__ = """Turn this branch into a mirror of another branch.
906
"""Turn this branch into a mirror of another branch.
1115
907
1116
By default, this command only works on branches that have not diverged.
1117
Branches are considered diverged if the destination branch's most recent
1118
commit is one that has not been merged (directly or indirectly) into the
1119
parent.
908
This command only works on branches that have not diverged. Branches are
909
considered diverged if the destination branch's most recent commit is one
910
that has not been merged (directly or indirectly) into the parent.
1120
911
1121
912
If branches have diverged, you can use 'bzr merge' to integrate the changes
1122
913
from one into the other. Once one branch has merged, the other should
1123
914
be able to pull it again.
1124
915
1125
If you want to replace your local changes and just want your branch to
1126
match the remote one, use pull --overwrite. This will work even if the two
1127
branches have diverged.
1128
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>.
916
If you want to forget your local changes and just update your branch to
917
match the remote one, use pull --overwrite.
918
919
If there is no default location set, the first pull will set it. After
920
that, you can omit the location to use the default. To change the
921
default, use --remember. The value will only be saved if the remote
922
location can be accessed.
1137
923
1138
924
Note: The location can be specified either in the form of a branch,
1139
925
or in the form of a path to a file containing a merge directive generated
1144
930
takes_options = ['remember', 'overwrite', 'revision',
1145
931
custom_help('verbose',
1146
932
help='Show logs of pulled revisions.'),
1147
custom_help('directory',
933
Option('directory',
1148
934
help='Branch to pull into, '
1149
'rather than the one containing the working directory.'),
935
'rather than the one containing the working directory.',
936
short_name='d',
937
type=unicode,
938
),
1150
939
Option('local',
1151
940
help="Perform a local pull in a bound "
1152
941
"branch. Local pulls are not applied to "
1153
942
"the master branch."
1154
943
),
1155
Option('show-base',
1156
help="Show base revision text in conflicts."),
1157
Option('overwrite-tags',
1158
help="Overwrite tags only."),
1159
944
]
1160
945
takes_args = ['location?']
1161
946
encoding_type = 'replace'
1162
947
1163
def run(self, location=None, remember=None, overwrite=False,
948
def run(self, location=None, remember=False, overwrite=False,
1164
949
revision=None, verbose=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 = []
950
directory=None, local=False):
1174
951
# FIXME: too much stuff is in the command class
1175
952
revision_id = None
1176
953
mergeable = None
1179
956
try:
1180
957
tree_to = WorkingTree.open_containing(directory)[0]
1181
958
branch_to = tree_to.branch
1182
self.add_cleanup(tree_to.lock_write().unlock)
1183
959
except errors.NoWorkingTree:
1184
960
tree_to = None
1185
961
branch_to = Branch.open_containing(directory)[0]
1186
self.add_cleanup(branch_to.lock_write().unlock)
1187
if show_base:
1188
warning(gettext("No working tree, ignoring --show-base"))
1189
962
1190
963
if local and not branch_to.get_bound_location():
1191
964
raise errors.LocalRequiresBoundBranch()
1192
965
1201
974
stored_loc = branch_to.get_parent()
1202
975
if location is None:
1203
976
if stored_loc is None:
1204
raise errors.BzrCommandError(gettext("No pull location known or"
1205
" specified."))
977
raise errors.BzrCommandError("No pull location known or"
978
" specified.")
1206
979
else:
1207
980
display_url = urlutils.unescape_for_display(stored_loc,
1208
981
self.outf.encoding)
1209
982
if not is_quiet():
1210
self.outf.write(gettext("Using saved parent location: %s\n") % display_url)
983
self.outf.write("Using saved parent location: %s\n" % display_url)
1211
984
location = stored_loc
1212
985
1213
986
revision = _get_one_revision('pull', revision)
1214
987
if mergeable is not None:
1215
988
if revision is not None:
1216
raise errors.BzrCommandError(gettext(
1217
'Cannot use -r with merge directives or bundles'))
989
raise errors.BzrCommandError(
990
'Cannot use -r with merge directives or bundles')
1218
991
mergeable.install_revisions(branch_to.repository)
1219
992
base_revision_id, revision_id, verified = \
1220
993
mergeable.get_merge_request(branch_to.repository)
1222
995
else:
1223
996
branch_from = Branch.open(location,
1224
997
possible_transports=possible_transports)
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
998
999
if branch_to.get_parent() is None or remember:
1231
1000
branch_to.set_parent(branch_from.base)
1232
1001
1233
if revision is not None:
1234
revision_id = revision.as_revision_id(branch_from)
1235
1236
if tree_to is not None:
1237
view_info = _get_view_info_for_change_reporter(tree_to)
1238
change_reporter = delta._ChangeReporter(
1239
unversioned_filter=tree_to.is_ignored,
1240
view_info=view_info)
1241
result = tree_to.pull(
1242
branch_from, overwrite, revision_id, change_reporter,
1243
local=local, show_base=show_base)
1244
else:
1245
result = branch_to.pull(
1246
branch_from, overwrite, revision_id, local=local)
1247
1248
result.report(self.outf)
1249
if verbose and result.old_revid != result.new_revid:
1250
log.show_branch_change(
1251
branch_to, self.outf, result.old_revno,
1252
result.old_revid)
1253
if getattr(result, 'tag_conflicts', None):
1254
return 1
1255
else:
1256
return 0
1002
if branch_from is not branch_to:
1003
branch_from.lock_read()
1004
try:
1005
if revision is not None:
1006
revision_id = revision.as_revision_id(branch_from)
1007
1008
branch_to.lock_write()
1009
try:
1010
if tree_to is not None:
1011
view_info = _get_view_info_for_change_reporter(tree_to)
1012
change_reporter = delta._ChangeReporter(
1013
unversioned_filter=tree_to.is_ignored,
1014
view_info=view_info)
1015
result = tree_to.pull(
1016
branch_from, overwrite, revision_id, change_reporter,
1017
possible_transports=possible_transports, local=local)
1018
else:
1019
result = branch_to.pull(
1020
branch_from, overwrite, revision_id, local=local)
1021
1022
result.report(self.outf)
1023
if verbose and result.old_revid != result.new_revid:
1024
log.show_branch_change(
1025
branch_to, self.outf, result.old_revno,
1026
result.old_revid)
1027
finally:
1028
branch_to.unlock()
1029
finally:
1030
if branch_from is not branch_to:
1031
branch_from.unlock()
1257
1032
1258
1033
1259
1034
class cmd_push(Command):
1260
__doc__ = """Update a mirror of this branch.
1035
"""Update a mirror of this branch.
1261
1036
1262
1037
The target branch will not have its working tree populated because this
1263
1038
is both expensive, and is not supported on remote file systems.
1276
1051
do a merge (see bzr help merge) from the other branch, and commit that.
1277
1052
After that you will be able to do a push without '--overwrite'.
1278
1053
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>.
1054
If there is no default push location set, the first push will set it.
1055
After that, you can omit the location to use the default. To change the
1056
default, use --remember. The value will only be saved if the remote
1057
location can be accessed.
1287
1058
"""
1288
1059
1289
1060
_see_also = ['pull', 'update', 'working-trees']
1291
1062
Option('create-prefix',
1292
1063
help='Create the path leading up to the branch '
1293
1064
'if it does not already exist.'),
1294
custom_help('directory',
1065
Option('directory',
1295
1066
help='Branch to push from, '
1296
'rather than the one containing the working directory.'),
1067
'rather than the one containing the working directory.',
1068
short_name='d',
1069
type=unicode,
1070
),
1297
1071
Option('use-existing-dir',
1298
1072
help='By default push will fail if the target'
1299
1073
' directory exists, but does not already'
1310
1084
Option('strict',
1311
1085
help='Refuse to push if there are uncommitted changes in'
1312
1086
' 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."),
1318
1087
]
1319
1088
takes_args = ['location?']
1320
1089
encoding_type = 'replace'
1321
1090
1322
def run(self, location=None, remember=None, overwrite=False,
1091
def run(self, location=None, remember=False, overwrite=False,
1323
1092
create_prefix=False, verbose=False, revision=None,
1324
1093
use_existing_dir=False, directory=None, stacked_on=None,
1325
stacked=False, strict=None, no_tree=False,
1326
overwrite_tags=False):
1094
stacked=False, strict=None):
1327
1095
from bzrlib.push import _show_push_branch
1328
1096
1329
if overwrite:
1330
overwrite = ["history", "tags"]
1331
elif overwrite_tags:
1332
overwrite = ["tags"]
1333
else:
1334
overwrite = []
1335
1336
1097
if directory is None:
1337
1098
directory = '.'
1338
1099
# Get the source branch
1339
1100
(tree, br_from,
1340
_unused) = controldir.ControlDir.open_containing_tree_or_branch(directory)
1101
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1102
if strict is None:
1103
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1104
if strict is None: strict = True # default value
1341
1105
# Get the tip's revision_id
1342
1106
revision = _get_one_revision('push', revision)
1343
1107
if revision is not None:
1344
1108
revision_id = revision.in_history(br_from).rev_id
1345
1109
else:
1346
1110
revision_id = None
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.')
1111
if strict and tree is not None and revision_id is None:
1112
if (tree.has_changes(tree.basis_tree())
1113
or len(tree.get_parent_ids()) > 1):
1114
raise errors.UncommittedChanges(
1115
tree, more='Use --no-strict to force the push.')
1116
if tree.last_revision() != tree.branch.last_revision():
1117
# The tree has lost sync with its branch, there is little
1118
# chance that the user is aware of it but he can still force
1119
# the push with --no-strict
1120
raise errors.OutOfDateTree(
1121
tree, more='Use --no-strict to force the push.')
1122
1352
1123
# Get the stacked_on branch, if any
1353
1124
if stacked_on is not None:
1354
1125
stacked_on = urlutils.normalize_url(stacked_on)
1364
1135
# error by the feedback given to them. RBC 20080227.
1365
1136
stacked_on = parent_url
1366
1137
if not stacked_on:
1367
raise errors.BzrCommandError(gettext(
1368
"Could not determine branch to refer to."))
1138
raise errors.BzrCommandError(
1139
"Could not determine branch to refer to.")
1369
1140
1370
1141
# Get the destination location
1371
1142
if location is None:
1372
1143
stored_loc = br_from.get_push_location()
1373
1144
if stored_loc is None:
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."))
1145
raise errors.BzrCommandError(
1146
"No push location known or specified.")
1384
1147
else:
1385
1148
display_url = urlutils.unescape_for_display(stored_loc,
1386
1149
self.outf.encoding)
1387
note(gettext("Using saved push location: %s") % display_url)
1150
self.outf.write("Using saved push location: %s\n" % display_url)
1388
1151
location = stored_loc
1389
1152
1390
1153
_show_push_branch(br_from, revision_id, location, self.outf,
1391
1154
verbose=verbose, overwrite=overwrite, remember=remember,
1392
1155
stacked_on=stacked_on, create_prefix=create_prefix,
1393
use_existing_dir=use_existing_dir, no_tree=no_tree)
1156
use_existing_dir=use_existing_dir)
1394
1157
1395
1158
1396
1159
class cmd_branch(Command):
1397
__doc__ = """Create a new branch that is a copy of an existing branch.
1160
"""Create a new branch that is a copy of an existing branch.
1398
1161
1399
1162
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1400
1163
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1405
1168
1406
1169
To retrieve the branch as of a particular revision, supply the --revision
1407
1170
parameter, as in "branch foo/bar -r 5".
1408
1409
The synonyms 'clone' and 'get' for this command are deprecated.
1410
1171
"""
1411
1172
1412
1173
_see_also = ['checkout']
1413
1174
takes_args = ['from_location', 'to_location?']
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."),
1175
takes_options = ['revision', Option('hardlink',
1176
help='Hard-link working tree files where possible.'),
1418
1177
Option('no-tree',
1419
1178
help="Create a branch without a working-tree."),
1420
1179
Option('switch',
1431
1190
' directory exists, but does not already'
1432
1191
' have a control directory. This flag will'
1433
1192
' allow branch to proceed.'),
1434
Option('bind',
1435
help="Bind new branch to from location."),
1436
1193
]
1437
1194
aliases = ['get', 'clone']
1438
1195
1439
1196
def run(self, from_location, to_location=None, revision=None,
1440
1197
hardlink=False, stacked=False, standalone=False, no_tree=False,
1441
use_existing_dir=False, switch=False, bind=False,
1442
files_from=None):
1198
use_existing_dir=False, switch=False):
1443
1199
from bzrlib import switch as _mod_switch
1444
1200
from bzrlib.tag import _merge_tags_if_possible
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(
1201
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1452
1202
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
1203
if (accelerator_tree is not None and
1204
accelerator_tree.supports_content_filtering()):
1457
1205
accelerator_tree = None
1458
if files_from is not None and files_from != from_location:
1459
accelerator_tree = WorkingTree.open(files_from)
1460
1206
revision = _get_one_revision('branch', revision)
1461
self.add_cleanup(br_from.lock_read().unlock)
1462
if revision is not None:
1463
revision_id = revision.as_revision_id(br_from)
1464
else:
1465
# FIXME - wt.last_revision, fallback to branch, fall back to
1466
# None or perhaps NULL_REVISION to mean copy nothing
1467
# RBC 20060209
1468
revision_id = br_from.last_revision()
1469
if to_location is None:
1470
to_location = getattr(br_from, "name", None)
1471
if not to_location:
1207
br_from.lock_read()
1208
try:
1209
if revision is not None:
1210
revision_id = revision.as_revision_id(br_from)
1211
else:
1212
# FIXME - wt.last_revision, fallback to branch, fall back to
1213
# None or perhaps NULL_REVISION to mean copy nothing
1214
# RBC 20060209
1215
revision_id = br_from.last_revision()
1216
if to_location is None:
1472
1217
to_location = urlutils.derive_to_location(from_location)
1473
to_transport = transport.get_transport(to_location)
1474
try:
1475
to_transport.mkdir('.')
1476
except errors.FileExists:
1218
to_transport = transport.get_transport(to_location)
1477
1219
try:
1478
to_dir = controldir.ControlDir.open_from_transport(
1479
to_transport)
1480
except errors.NotBranchError:
1220
to_transport.mkdir('.')
1221
except errors.FileExists:
1481
1222
if not use_existing_dir:
1482
raise errors.BzrCommandError(gettext('Target directory "%s" '
1483
'already exists.') % to_location)
1484
else:
1485
to_dir = None
1486
else:
1487
try:
1488
to_dir.open_branch()
1489
except errors.NotBranchError:
1490
pass
1491
else:
1492
raise errors.AlreadyBranchError(to_location)
1493
except errors.NoSuchFile:
1494
raise errors.BzrCommandError(gettext('Parent of "%s" does not exist.')
1495
% to_location)
1496
else:
1497
to_dir = None
1498
if to_dir is None:
1223
raise errors.BzrCommandError('Target directory "%s" '
1224
'already exists.' % to_location)
1225
else:
1226
try:
1227
bzrdir.BzrDir.open_from_transport(to_transport)
1228
except errors.NotBranchError:
1229
pass
1230
else:
1231
raise errors.AlreadyBranchError(to_location)
1232
except errors.NoSuchFile:
1233
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1234
% to_location)
1499
1235
try:
1500
1236
# preserve whatever source format we have.
1501
to_dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1237
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1502
1238
possible_transports=[to_transport],
1503
1239
accelerator_tree=accelerator_tree,
1504
1240
hardlink=hardlink, stacked=stacked,
1505
1241
force_new_repo=standalone,
1506
1242
create_tree_if_local=not no_tree,
1507
1243
source_branch=br_from)
1508
branch = to_dir.open_branch(
1509
possible_transports=[
1510
br_from.bzrdir.root_transport, to_transport])
1244
branch = dir.open_branch()
1511
1245
except errors.NoSuchRevision:
1512
1246
to_transport.delete_tree('.')
1513
msg = gettext("The branch {0} has no revision {1}.").format(
1514
from_location, revision)
1247
msg = "The branch %s has no revision %s." % (from_location,
1248
revision)
1515
1249
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)
1523
_merge_tags_if_possible(br_from, branch)
1524
# If the source branch is stacked, the new branch may
1525
# be stacked whether we asked for that explicitly or not.
1526
# We therefore need a try/except here and not just 'if stacked:'
1527
try:
1528
note(gettext('Created new stacked branch referring to %s.') %
1529
branch.get_stacked_on_url())
1530
except (errors.NotStacked, errors.UnstackableBranchFormat,
1531
errors.UnstackableRepositoryFormat), e:
1532
note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1533
if bind:
1534
# Bind to the parent
1535
parent_branch = Branch.open(from_location)
1536
branch.bind(parent_branch)
1537
note(gettext('New branch bound to %s') % from_location)
1538
if switch:
1539
# Switch to the new branch
1540
wt, _ = WorkingTree.open_containing('.')
1541
_mod_switch.switch(wt.bzrdir, branch)
1542
note(gettext('Switched to branch: %s'),
1543
urlutils.unescape_for_display(branch.base, 'utf-8'))
1544
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)))
1250
_merge_tags_if_possible(br_from, branch)
1251
# If the source branch is stacked, the new branch may
1252
# be stacked whether we asked for that explicitly or not.
1253
# We therefore need a try/except here and not just 'if stacked:'
1254
try:
1255
note('Created new stacked branch referring to %s.' %
1256
branch.get_stacked_on_url())
1257
except (errors.NotStacked, errors.UnstackableBranchFormat,
1258
errors.UnstackableRepositoryFormat), e:
1259
note('Branched %d revision(s).' % branch.revno())
1260
if switch:
1261
# Switch to the new branch
1262
wt, _ = WorkingTree.open_containing('.')
1263
_mod_switch.switch(wt.bzrdir, branch)
1264
note('Switched to branch: %s',
1265
urlutils.unescape_for_display(branch.base, 'utf-8'))
1266
finally:
1267
br_from.unlock()
1594
1268
1595
1269
1596
1270
class cmd_checkout(Command):
1597
__doc__ = """Create a new checkout of an existing branch.
1271
"""Create a new checkout of an existing branch.
1598
1272
1599
1273
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1600
1274
the branch found in '.'. This is useful if you have removed the working tree
1614
1288
code.)
1615
1289
"""
1616
1290
1617
_see_also = ['checkouts', 'branch', 'working-trees', 'remove-tree']
1291
_see_also = ['checkouts', 'branch']
1618
1292
takes_args = ['branch_location?', 'to_location?']
1619
1293
takes_options = ['revision',
1620
1294
Option('lightweight',
1637
1311
if branch_location is None:
1638
1312
branch_location = osutils.getcwd()
1639
1313
to_location = branch_location
1640
accelerator_tree, source = controldir.ControlDir.open_tree_or_branch(
1314
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1641
1315
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
1647
1316
revision = _get_one_revision('checkout', revision)
1648
if files_from is not None and files_from != branch_location:
1317
if files_from is not None:
1649
1318
accelerator_tree = WorkingTree.open(files_from)
1650
1319
if revision is not None:
1651
1320
revision_id = revision.as_revision_id(source)
1668
1337
1669
1338
1670
1339
class cmd_renames(Command):
1671
__doc__ = """Show list of renamed files.
1340
"""Show list of renamed files.
1672
1341
"""
1673
1342
# TODO: Option to show renames between two historical versions.
1674
1343
1679
1348
@display_command
1680
1349
def run(self, dir=u'.'):
1681
1350
tree = WorkingTree.open_containing(dir)[0]
1682
self.add_cleanup(tree.lock_read().unlock)
1683
old_tree = tree.basis_tree()
1684
self.add_cleanup(old_tree.lock_read().unlock)
1685
renames = []
1686
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1687
for f, paths, c, v, p, n, k, e in iterator:
1688
if paths[0] == paths[1]:
1689
continue
1690
if None in (paths):
1691
continue
1692
renames.append(paths)
1693
renames.sort()
1694
for old_name, new_name in renames:
1695
self.outf.write("%s => %s\n" % (old_name, new_name))
1351
tree.lock_read()
1352
try:
1353
new_inv = tree.inventory
1354
old_tree = tree.basis_tree()
1355
old_tree.lock_read()
1356
try:
1357
old_inv = old_tree.inventory
1358
renames = []
1359
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1360
for f, paths, c, v, p, n, k, e in iterator:
1361
if paths[0] == paths[1]:
1362
continue
1363
if None in (paths):
1364
continue
1365
renames.append(paths)
1366
renames.sort()
1367
for old_name, new_name in renames:
1368
self.outf.write("%s => %s\n" % (old_name, new_name))
1369
finally:
1370
old_tree.unlock()
1371
finally:
1372
tree.unlock()
1696
1373
1697
1374
1698
1375
class cmd_update(Command):
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
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.
1376
"""Update a tree to have the latest code committed to its branch.
1377
1378
This will perform a merge into the working tree, and may generate
1379
conflicts. If you have any local changes, you will still
1380
need to commit them after the update for the update to be complete.
1381
1382
If you want to discard your local changes, you can just do a
1383
'bzr revert' instead of 'bzr commit' after the update.
1726
1384
"""
1727
1385
1728
1386
_see_also = ['pull', 'working-trees', 'status-flags']
1729
1387
takes_args = ['dir?']
1730
takes_options = ['revision',
1731
Option('show-base',
1732
help="Show base revision text in conflicts."),
1733
]
1734
1388
aliases = ['up']
1735
1389
1736
def run(self, dir=None, revision=None, show_base=None):
1737
if revision is not None and len(revision) != 1:
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"))
1749
branch = tree.branch
1390
def run(self, dir='.'):
1391
tree = WorkingTree.open_containing(dir)[0]
1750
1392
possible_transports = []
1751
master = branch.get_master_branch(
1393
master = tree.branch.get_master_branch(
1752
1394
possible_transports=possible_transports)
1753
1395
if master is not None:
1754
branch_location = master.base
1755
1396
tree.lock_write()
1756
1397
else:
1757
branch_location = tree.branch.base
1758
1398
tree.lock_tree_write()
1759
self.add_cleanup(tree.unlock)
1760
# get rid of the final '/' and be ready for display
1761
branch_location = urlutils.unescape_for_display(
1762
branch_location.rstrip('/'),
1763
self.outf.encoding)
1764
existing_pending_merges = tree.get_parent_ids()[1:]
1765
if master is None:
1766
old_tip = None
1767
else:
1768
# may need to fetch data into a heavyweight checkout
1769
# XXX: this may take some time, maybe we should display a
1770
# message
1771
old_tip = branch.update(possible_transports)
1772
if revision is not None:
1773
revision_id = revision[0].as_revision_id(branch)
1774
else:
1775
revision_id = branch.last_revision()
1776
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
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))
1780
return 0
1781
view_info = _get_view_info_for_change_reporter(tree)
1782
change_reporter = delta._ChangeReporter(
1783
unversioned_filter=tree.is_ignored,
1784
view_info=view_info)
1785
1399
try:
1400
existing_pending_merges = tree.get_parent_ids()[1:]
1401
last_rev = _mod_revision.ensure_null(tree.last_revision())
1402
if last_rev == _mod_revision.ensure_null(
1403
tree.branch.last_revision()):
1404
# may be up to date, check master too.
1405
if master is None or last_rev == _mod_revision.ensure_null(
1406
master.last_revision()):
1407
revno = tree.branch.revision_id_to_revno(last_rev)
1408
note("Tree is up to date at revision %d." % (revno,))
1409
return 0
1410
view_info = _get_view_info_for_change_reporter(tree)
1786
1411
conflicts = tree.update(
1787
change_reporter,
1788
possible_transports=possible_transports,
1789
revision=revision_id,
1790
old_tip=old_tip,
1791
show_base=show_base)
1792
except errors.NoSuchRevision, e:
1793
raise errors.BzrCommandError(gettext(
1794
"branch has no revision %s\n"
1795
"bzr update --revision only works"
1796
" for a revision in the branch history")
1797
% (e.revision))
1798
revno = tree.branch.revision_id_to_dotted_revno(
1799
_mod_revision.ensure_null(tree.last_revision()))
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'."))
1806
if conflicts != 0:
1807
return 1
1808
else:
1809
return 0
1412
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1413
view_info=view_info), possible_transports=possible_transports)
1414
revno = tree.branch.revision_id_to_revno(
1415
_mod_revision.ensure_null(tree.last_revision()))
1416
note('Updated to revision %d.' % (revno,))
1417
if tree.get_parent_ids()[1:] != existing_pending_merges:
1418
note('Your local commits will now show as pending merges with '
1419
"'bzr status', and can be committed with 'bzr commit'.")
1420
if conflicts != 0:
1421
return 1
1422
else:
1423
return 0
1424
finally:
1425
tree.unlock()
1810
1426
1811
1427
1812
1428
class cmd_info(Command):
1813
__doc__ = """Show information about a working tree, branch or repository.
1429
"""Show information about a working tree, branch or repository.
1814
1430
1815
1431
This command will show all known locations and formats associated to the
1816
1432
tree, branch or repository.
1849
1465
else:
1850
1466
noise_level = 0
1851
1467
from bzrlib.info import show_bzrdir_info
1852
show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1468
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1853
1469
verbose=noise_level, outfile=self.outf)
1854
1470
1855
1471
1856
1472
class cmd_remove(Command):
1857
__doc__ = """Remove files or directories.
1473
"""Remove files or directories.
1858
1474
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.
1475
This makes bzr stop tracking changes to the specified files. bzr will delete
1476
them if they can easily be recovered using revert. If no options or
1477
parameters are given bzr will scan for files that are being tracked by bzr
1478
but missing in your tree and stop tracking them for you.
1864
1479
"""
1865
1480
takes_args = ['file*']
1866
1481
takes_options = ['verbose',
1868
1483
RegistryOption.from_kwargs('file-deletion-strategy',
1869
1484
'The file deletion mode to be used.',
1870
1485
title='Deletion Strategy', value_switches=True, enum_switch=False,
1871
safe='Backup changed files (default).',
1486
safe='Only delete files if they can be'
1487
' safely recovered (default).',
1872
1488
keep='Delete from bzr but leave the working copy.',
1873
no_backup='Don\'t backup changed files.'),
1874
]
1489
force='Delete all the specified files, even if they can not be '
1490
'recovered and even if they are non-empty directories.')]
1875
1491
aliases = ['rm', 'del']
1876
1492
encoding_type = 'replace'
1877
1493
1878
1494
def run(self, file_list, verbose=False, new=False,
1879
1495
file_deletion_strategy='safe'):
1880
1881
tree, file_list = WorkingTree.open_containing_paths(file_list)
1496
tree, file_list = tree_files(file_list)
1882
1497
1883
1498
if file_list is not None:
1884
1499
file_list = [f for f in file_list]
1885
1500
1886
self.add_cleanup(tree.lock_write().unlock)
1887
# Heuristics should probably all move into tree.remove_smart or
1888
# some such?
1889
if new:
1890
added = tree.changes_from(tree.basis_tree(),
1891
specific_files=file_list).added
1892
file_list = sorted([f[0] for f in added], reverse=True)
1893
if len(file_list) == 0:
1894
raise errors.BzrCommandError(gettext('No matching files.'))
1895
elif file_list is None:
1896
# missing files show up in iter_changes(basis) as
1897
# versioned-with-no-kind.
1898
missing = []
1899
for change in tree.iter_changes(tree.basis_tree()):
1900
# Find paths in the working tree that have no kind:
1901
if change[1][1] is not None and change[6][1] is None:
1902
missing.append(change[1][1])
1903
file_list = sorted(missing, reverse=True)
1904
file_deletion_strategy = 'keep'
1905
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1906
keep_files=file_deletion_strategy=='keep',
1907
force=(file_deletion_strategy=='no-backup'))
1501
tree.lock_write()
1502
try:
1503
# Heuristics should probably all move into tree.remove_smart or
1504
# some such?
1505
if new:
1506
added = tree.changes_from(tree.basis_tree(),
1507
specific_files=file_list).added
1508
file_list = sorted([f[0] for f in added], reverse=True)
1509
if len(file_list) == 0:
1510
raise errors.BzrCommandError('No matching files.')
1511
elif file_list is None:
1512
# missing files show up in iter_changes(basis) as
1513
# versioned-with-no-kind.
1514
missing = []
1515
for change in tree.iter_changes(tree.basis_tree()):
1516
# Find paths in the working tree that have no kind:
1517
if change[1][1] is not None and change[6][1] is None:
1518
missing.append(change[1][1])
1519
file_list = sorted(missing, reverse=True)
1520
file_deletion_strategy = 'keep'
1521
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1522
keep_files=file_deletion_strategy=='keep',
1523
force=file_deletion_strategy=='force')
1524
finally:
1525
tree.unlock()
1908
1526
1909
1527
1910
1528
class cmd_file_id(Command):
1911
__doc__ = """Print file_id of a particular file or directory.
1529
"""Print file_id of a particular file or directory.
1912
1530
1913
1531
The file_id is assigned when the file is first added and remains the
1914
1532
same through all revisions where the file exists, even when it is
1930
1548
1931
1549
1932
1550
class cmd_file_path(Command):
1933
__doc__ = """Print path of file_ids to a file or directory.
1551
"""Print path of file_ids to a file or directory.
1934
1552
1935
1553
This prints one line for each directory down to the target,
1936
1554
starting at the branch root.
1952
1570
1953
1571
1954
1572
class cmd_reconcile(Command):
1955
__doc__ = """Reconcile bzr metadata in a branch.
1573
"""Reconcile bzr metadata in a branch.
1956
1574
1957
1575
This can correct data mismatches that may have been caused by
1958
1576
previous ghost operations or bzr upgrades. You should only
1972
1590
1973
1591
_see_also = ['check']
1974
1592
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
]
1981
1593
1982
def run(self, branch=".", canonicalize_chks=False):
1594
def run(self, branch="."):
1983
1595
from bzrlib.reconcile import reconcile
1984
dir = controldir.ControlDir.open(branch)
1985
reconcile(dir, canonicalize_chks=canonicalize_chks)
1596
dir = bzrdir.BzrDir.open(branch)
1597
reconcile(dir)
1986
1598
1987
1599
1988
1600
class cmd_revision_history(Command):
1989
__doc__ = """Display the list of revision ids on a branch."""
1601
"""Display the list of revision ids on a branch."""
1990
1602
1991
1603
_see_also = ['log']
1992
1604
takes_args = ['location?']
1996
1608
@display_command
1997
1609
def run(self, location="."):
1998
1610
branch = Branch.open_containing(location)[0]
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):
1611
for revid in branch.revision_history():
2004
1612
self.outf.write(revid)
2005
1613
self.outf.write('\n')
2006
1614
2007
1615
2008
1616
class cmd_ancestry(Command):
2009
__doc__ = """List all revisions merged into this branch."""
1617
"""List all revisions merged into this branch."""
2010
1618
2011
1619
_see_also = ['log', 'revision-history']
2012
1620
takes_args = ['location?']
2024
1632
b = wt.branch
2025
1633
last_revision = wt.last_revision()
2026
1634
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
1635
revision_ids = b.repository.get_ancestry(last_revision)
1636
revision_ids.pop(0)
1637
for revision_id in revision_ids:
2034
1638
self.outf.write(revision_id + '\n')
2035
1639
2036
1640
2037
1641
class cmd_init(Command):
2038
__doc__ = """Make a directory into a versioned branch.
1642
"""Make a directory into a versioned branch.
2039
1643
2040
1644
Use this to create an empty branch, or before importing an
2041
1645
existing project.
2066
1670
RegistryOption('format',
2067
1671
help='Specify a format for this branch. '
2068
1672
'See "help formats".',
2069
lazy_registry=('bzrlib.controldir', 'format_registry'),
2070
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1673
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1674
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2071
1675
value_switches=True,
2072
1676
title="Branch format",
2073
1677
),
2074
1678
Option('append-revisions-only',
2075
1679
help='Never change revnos or the existing log.'
2076
' Append revisions to it only.'),
2077
Option('no-tree',
2078
'Create a branch without a working tree.')
1680
' Append revisions to it only.')
2079
1681
]
2080
1682
def run(self, location=None, format=None, append_revisions_only=False,
2081
create_prefix=False, no_tree=False):
1683
create_prefix=False):
2082
1684
if format is None:
2083
format = controldir.format_registry.make_bzrdir('default')
1685
format = bzrdir.format_registry.make_bzrdir('default')
2084
1686
if location is None:
2085
1687
location = u'.'
2086
1688
2095
1697
to_transport.ensure_base()
2096
1698
except errors.NoSuchFile:
2097
1699
if not create_prefix:
2098
raise errors.BzrCommandError(gettext("Parent directory of %s"
1700
raise errors.BzrCommandError("Parent directory of %s"
2099
1701
" does not exist."
2100
1702
"\nYou may supply --create-prefix to create all"
2101
" leading parent directories.")
1703
" leading parent directories."
2102
1704
% location)
2103
1705
to_transport.create_prefix()
2104
1706
2105
1707
try:
2106
a_bzrdir = controldir.ControlDir.open_from_transport(to_transport)
1708
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
2107
1709
except errors.NotBranchError:
2108
1710
# really a NotBzrDir error...
2109
create_branch = controldir.ControlDir.create_branch_convenience
2110
if no_tree:
2111
force_new_tree = False
2112
else:
2113
force_new_tree = None
1711
create_branch = bzrdir.BzrDir.create_branch_convenience
2114
1712
branch = create_branch(to_transport.base, format=format,
2115
possible_transports=[to_transport],
2116
force_new_tree=force_new_tree)
1713
possible_transports=[to_transport])
2117
1714
a_bzrdir = branch.bzrdir
2118
1715
else:
2119
1716
from bzrlib.transport.local import LocalTransport
2123
1720
raise errors.BranchExistsWithoutWorkingTree(location)
2124
1721
raise errors.AlreadyBranchError(location)
2125
1722
branch = a_bzrdir.create_branch()
2126
if not no_tree and not a_bzrdir.has_workingtree():
2127
a_bzrdir.create_workingtree()
1723
a_bzrdir.create_workingtree()
2128
1724
if append_revisions_only:
2129
1725
try:
2130
1726
branch.set_append_revisions_only(True)
2131
1727
except errors.UpgradeRequired:
2132
raise errors.BzrCommandError(gettext('This branch format cannot be set'
2133
' to append-revisions-only. Try --default.'))
1728
raise errors.BzrCommandError('This branch format cannot be set'
1729
' to append-revisions-only. Try --default.')
2134
1730
if not is_quiet():
2135
1731
from bzrlib.info import describe_layout, describe_format
2136
1732
try:
2140
1736
repository = branch.repository
2141
1737
layout = describe_layout(repository, branch, tree).lower()
2142
1738
format = describe_format(a_bzrdir, repository, branch, tree)
2143
self.outf.write(gettext("Created a {0} (format: {1})\n").format(
2144
layout, format))
1739
self.outf.write("Created a %s (format: %s)\n" % (layout, format))
2145
1740
if repository.is_shared():
2146
1741
#XXX: maybe this can be refactored into transport.path_or_url()
2147
1742
url = repository.bzrdir.root_transport.external_url()
2149
1744
url = urlutils.local_path_from_url(url)
2150
1745
except errors.InvalidURL:
2151
1746
pass
2152
self.outf.write(gettext("Using shared repository: %s\n") % url)
1747
self.outf.write("Using shared repository: %s\n" % url)
2153
1748
2154
1749
2155
1750
class cmd_init_repository(Command):
2156
__doc__ = """Create a shared repository for branches to share storage space.
1751
"""Create a shared repository to hold branches.
2157
1752
2158
1753
New branches created under the repository directory will store their
2159
revisions in the repository, not in the branch directory. For branches
2160
with shared history, this reduces the amount of storage needed and
2161
speeds up the creation of new branches.
1754
revisions in the repository, not in the branch directory.
2162
1755
2163
If the --no-trees option is given then the branches in the repository
2164
will not have working trees by default. They will still exist as
2165
directories on disk, but they will not have separate copies of the
2166
files at a certain revision. This can be useful for repositories that
2167
store branches which are interacted with through checkouts or remote
2168
branches, such as on a server.
1756
If the --no-trees option is used then the branches in the repository
1757
will not have working trees by default.
2169
1758
2170
1759
:Examples:
2171
Create a shared repository holding just branches::
1760
Create a shared repositories holding just branches::
2172
1761
2173
1762
bzr init-repo --no-trees repo
2174
1763
bzr init repo/trunk
2185
1774
takes_options = [RegistryOption('format',
2186
1775
help='Specify a format for this repository. See'
2187
1776
' "bzr help formats" for details.',
2188
lazy_registry=('bzrlib.controldir', 'format_registry'),
2189
converter=lambda name: controldir.format_registry.make_bzrdir(name),
1777
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1778
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
2190
1779
value_switches=True, title='Repository format'),
2191
1780
Option('no-trees',
2192
1781
help='Branches in the repository will default to'
2196
1785
2197
1786
def run(self, location, format=None, no_trees=False):
2198
1787
if format is None:
2199
format = controldir.format_registry.make_bzrdir('default')
1788
format = bzrdir.format_registry.make_bzrdir('default')
2200
1789
2201
1790
if location is None:
2202
1791
location = '.'
2203
1792
2204
1793
to_transport = transport.get_transport(location)
1794
to_transport.ensure_base()
2205
1795
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()))
1796
newdir = format.initialize_on_transport(to_transport)
1797
repo = newdir.create_repository(shared=True)
1798
repo.set_make_working_trees(not no_trees)
2212
1799
if not is_quiet():
2213
1800
from bzrlib.info import show_bzrdir_info
2214
show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
1801
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
2215
1802
2216
1803
2217
1804
class cmd_diff(Command):
2218
__doc__ = """Show differences in the working tree, between revisions or branches.
1805
"""Show differences in the working tree, between revisions or branches.
2219
1806
2220
1807
If no arguments are given, all changes for the current tree are listed.
2221
1808
If files are given, only the changes in those files are listed.
2227
1814
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
2228
1815
produces patches suitable for "patch -p1".
2229
1816
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
2237
1817
:Exit values:
2238
1818
1 - changed
2239
1819
2 - unrepresentable changes
2249
1829
2250
1830
bzr diff -r1
2251
1831
2252
Difference between revision 3 and revision 1::
2253
2254
bzr diff -r1..3
2255
2256
Difference between revision 3 and revision 1 for branch xxx::
2257
2258
bzr diff -r1..3 xxx
2259
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::
2265
2266
bzr diff -cX
2267
2268
Note that in the case of a merge, the -c option shows the changes
2269
compared to the left hand parent. To see the changes against
2270
another parent, use::
2271
2272
bzr diff -r<chosen_parent>..X
2273
2274
The changes between the current revision and the previous revision
2275
(equivalent to -c-1 and -r-2..-1)
2276
2277
bzr diff -r-2..
1832
Difference between revision 2 and revision 1::
1833
1834
bzr diff -r1..2
1835
1836
Difference between revision 2 and revision 1 for branch xxx::
1837
1838
bzr diff -r1..2 xxx
2278
1839
2279
1840
Show just the differences for file NEWS::
2280
1841
2295
1856
Same as 'bzr diff' but prefix paths with old/ and new/::
2296
1857
2297
1858
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
2302
1859
"""
2303
1860
_see_also = ['status']
2304
1861
takes_args = ['file*']
2323
1880
help='Use this command to compare files.',
2324
1881
type=unicode,
2325
1882
),
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
),
2335
1883
]
2336
1884
aliases = ['di', 'dif']
2337
1885
encoding_type = 'exact'
2338
1886
2339
1887
@display_command
2340
1888
def run(self, revision=None, file_list=None, diff_options=None,
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)
1889
prefix=None, old=None, new=None, using=None):
1890
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
2345
1891
2346
1892
if (prefix is None) or (prefix == '0'):
2347
1893
# diff -p0 format
2353
1899
elif ':' in prefix:
2354
1900
old_label, new_label = prefix.split(":")
2355
1901
else:
2356
raise errors.BzrCommandError(gettext(
1902
raise errors.BzrCommandError(
2357
1903
'--prefix expects two values separated by a colon'
2358
' (eg "old/:new/")'))
1904
' (eg "old/:new/")')
2359
1905
2360
1906
if revision and len(revision) > 2:
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'))
2368
2369
(old_tree, new_tree,
2370
old_branch, new_branch,
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()
1907
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1908
' one or two revision specifiers')
1909
1910
old_tree, new_tree, specific_files, extra_trees = \
1911
_get_trees_to_diff(file_list, revision, old, new,
1912
apply_view=True)
2375
1913
return show_diff_trees(old_tree, new_tree, sys.stdout,
2376
1914
specific_files=specific_files,
2377
1915
external_diff_options=diff_options,
2378
1916
old_label=old_label, new_label=new_label,
2379
extra_trees=extra_trees,
2380
path_encoding=path_encoding,
2381
using=using, context=context,
2382
format_cls=format)
1917
extra_trees=extra_trees, using=using)
2383
1918
2384
1919
2385
1920
class cmd_deleted(Command):
2386
__doc__ = """List files deleted in the working tree.
1921
"""List files deleted in the working tree.
2387
1922
"""
2388
1923
# TODO: Show files deleted since a previous revision, or
2389
1924
# between two revisions.
2392
1927
# level of effort but possibly much less IO. (Or possibly not,
2393
1928
# if the directories are very large...)
2394
1929
_see_also = ['status', 'ls']
2395
takes_options = ['directory', 'show-ids']
1930
takes_options = ['show-ids']
2396
1931
2397
1932
@display_command
2398
def run(self, show_ids=False, directory=u'.'):
2399
tree = WorkingTree.open_containing(directory)[0]
2400
self.add_cleanup(tree.lock_read().unlock)
2401
old = tree.basis_tree()
2402
self.add_cleanup(old.lock_read().unlock)
2403
for path, ie in old.iter_entries_by_dir():
2404
if not tree.has_id(ie.file_id):
2405
self.outf.write(path)
2406
if show_ids:
2407
self.outf.write(' ')
2408
self.outf.write(ie.file_id)
2409
self.outf.write('\n')
1933
def run(self, show_ids=False):
1934
tree = WorkingTree.open_containing(u'.')[0]
1935
tree.lock_read()
1936
try:
1937
old = tree.basis_tree()
1938
old.lock_read()
1939
try:
1940
for path, ie in old.inventory.iter_entries():
1941
if not tree.has_id(ie.file_id):
1942
self.outf.write(path)
1943
if show_ids:
1944
self.outf.write(' ')
1945
self.outf.write(ie.file_id)
1946
self.outf.write('\n')
1947
finally:
1948
old.unlock()
1949
finally:
1950
tree.unlock()
2410
1951
2411
1952
2412
1953
class cmd_modified(Command):
2413
__doc__ = """List files modified in working tree.
1954
"""List files modified in working tree.
2414
1955
"""
2415
1956
2416
1957
hidden = True
2417
1958
_see_also = ['status', 'ls']
2418
takes_options = ['directory', 'null']
1959
takes_options = [
1960
Option('null',
1961
help='Write an ascii NUL (\\0) separator '
1962
'between files rather than a newline.')
1963
]
2419
1964
2420
1965
@display_command
2421
def run(self, null=False, directory=u'.'):
2422
tree = WorkingTree.open_containing(directory)[0]
2423
self.add_cleanup(tree.lock_read().unlock)
1966
def run(self, null=False):
1967
tree = WorkingTree.open_containing(u'.')[0]
2424
1968
td = tree.changes_from(tree.basis_tree())
2425
self.cleanup_now()
2426
1969
for path, id, kind, text_modified, meta_modified in td.modified:
2427
1970
if null:
2428
1971
self.outf.write(path + '\0')
2431
1974
2432
1975
2433
1976
class cmd_added(Command):
2434
__doc__ = """List files added in working tree.
1977
"""List files added in working tree.
2435
1978
"""
2436
1979
2437
1980
hidden = True
2438
1981
_see_also = ['status', 'ls']
2439
takes_options = ['directory', 'null']
1982
takes_options = [
1983
Option('null',
1984
help='Write an ascii NUL (\\0) separator '
1985
'between files rather than a newline.')
1986
]
2440
1987
2441
1988
@display_command
2442
def run(self, null=False, directory=u'.'):
2443
wt = WorkingTree.open_containing(directory)[0]
2444
self.add_cleanup(wt.lock_read().unlock)
2445
basis = wt.basis_tree()
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):
2455
continue
2456
if null:
2457
self.outf.write(path + '\0')
2458
else:
2459
self.outf.write(osutils.quotefn(path) + '\n')
1989
def run(self, null=False):
1990
wt = WorkingTree.open_containing(u'.')[0]
1991
wt.lock_read()
1992
try:
1993
basis = wt.basis_tree()
1994
basis.lock_read()
1995
try:
1996
basis_inv = basis.inventory
1997
inv = wt.inventory
1998
for file_id in inv:
1999
if file_id in basis_inv:
2000
continue
2001
if inv.is_root(file_id) and len(basis_inv) == 0:
2002
continue
2003
path = inv.id2path(file_id)
2004
if not os.access(osutils.abspath(path), os.F_OK):
2005
continue
2006
if null:
2007
self.outf.write(path + '\0')
2008
else:
2009
self.outf.write(osutils.quotefn(path) + '\n')
2010
finally:
2011
basis.unlock()
2012
finally:
2013
wt.unlock()
2460
2014
2461
2015
2462
2016
class cmd_root(Command):
2463
__doc__ = """Show the tree root directory.
2017
"""Show the tree root directory.
2464
2018
2465
2019
The root is the nearest enclosing directory with a .bzr control
2466
2020
directory."""
2477
2031
try:
2478
2032
return int(limitstring)
2479
2033
except ValueError:
2480
msg = gettext("The limit argument must be an integer.")
2034
msg = "The limit argument must be an integer."
2481
2035
raise errors.BzrCommandError(msg)
2482
2036
2483
2037
2485
2039
try:
2486
2040
return int(s)
2487
2041
except ValueError:
2488
msg = gettext("The levels argument must be an integer.")
2042
msg = "The levels argument must be an integer."
2489
2043
raise errors.BzrCommandError(msg)
2490
2044
2491
2045
2492
2046
class cmd_log(Command):
2493
__doc__ = """Show historical log for a branch or subset of a branch.
2047
"""Show historical log for a branch or subset of a branch.
2494
2048
2495
2049
log is bzr's default tool for exploring the history of a branch.
2496
2050
The branch to use is taken from the first parameter. If no parameters
2601
2155
2602
2156
:Other filtering:
2603
2157
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.
2158
The --message option can be used for finding revisions that match a
2159
regular expression in a commit message.
2609
2160
2610
2161
:Tips & tricks:
2611
2162
2612
2163
GUI tools and IDEs are often better at exploring history than command
2613
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2614
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2615
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2616
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2164
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2165
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2166
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2167
2168
Web interfaces are often better at exploring history than command line
2169
tools, particularly for branches on servers. You may prefer Loggerhead
2170
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2617
2171
2618
2172
You may find it useful to add the aliases below to ``bazaar.conf``::
2619
2173
2660
2214
help='Show just the specified revision.'
2661
2215
' See also "help revisionspec".'),
2662
2216
'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
),
2668
2217
Option('levels',
2669
2218
short_name='n',
2670
2219
help='Number of levels to display - 0 for all, 1 for flat.',
2671
2220
argname='N',
2672
2221
type=_parse_levels),
2673
2222
Option('message',
2223
short_name='m',
2674
2224
help='Show revisions whose message matches this '
2675
2225
'regular expression.',
2676
type=str,
2677
hidden=True),
2226
type=str),
2678
2227
Option('limit',
2679
2228
short_name='l',
2680
2229
help='Limit the output to the first N revisions.',
2683
2232
Option('show-diff',
2684
2233
short_name='p',
2685
2234
help='Show changes made in each revision as a patch.'),
2686
Option('include-merged',
2235
Option('include-merges',
2687
2236
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)
2719
2237
]
2720
2238
encoding_type = 'replace'
2721
2239
2731
2249
message=None,
2732
2250
limit=None,
2733
2251
show_diff=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
):
2252
include_merges=False):
2746
2253
from bzrlib.log import (
2747
2254
Logger,
2748
2255
make_log_request_dict,
2749
2256
_get_info_for_log_files,
2750
2257
)
2751
2258
direction = (forward and 'forward') or 'reverse'
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:
2259
if include_merges:
2772
2260
if levels is None:
2773
2261
levels = 0
2774
2262
else:
2775
raise errors.BzrCommandError(gettext(
2776
'{0} and {1} are mutually exclusive').format(
2777
'--levels', '--include-merged'))
2263
raise errors.BzrCommandError(
2264
'--levels and --include-merges are mutually exclusive')
2778
2265
2779
2266
if change is not None:
2780
2267
if len(change) > 1:
2781
2268
raise errors.RangeInChangeOption()
2782
2269
if revision is not None:
2783
raise errors.BzrCommandError(gettext(
2784
'{0} and {1} are mutually exclusive').format(
2785
'--revision', '--change'))
2270
raise errors.BzrCommandError(
2271
'--revision and --change are mutually exclusive')
2786
2272
else:
2787
2273
revision = change
2788
2274
2789
2275
file_ids = []
2790
2276
filter_by_dir = False
2791
if file_list:
2792
# find the file ids to log and check for directory filtering
2793
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2794
revision, file_list, self.add_cleanup)
2795
for relpath, file_id, kind in file_info_list:
2796
if file_id is None:
2797
raise errors.BzrCommandError(gettext(
2798
"Path unknown at end or start of revision range: %s") %
2799
relpath)
2800
# If the relpath is the top of the tree, we log everything
2801
if relpath == '':
2802
file_ids = []
2803
break
2277
b = None
2278
try:
2279
if file_list:
2280
# find the file ids to log and check for directory filtering
2281
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2282
revision, file_list)
2283
for relpath, file_id, kind in file_info_list:
2284
if file_id is None:
2285
raise errors.BzrCommandError(
2286
"Path unknown at end or start of revision range: %s" %
2287
relpath)
2288
# If the relpath is the top of the tree, we log everything
2289
if relpath == '':
2290
file_ids = []
2291
break
2292
else:
2293
file_ids.append(file_id)
2294
filter_by_dir = filter_by_dir or (
2295
kind in ['directory', 'tree-reference'])
2296
else:
2297
# log everything
2298
# FIXME ? log the current subdir only RBC 20060203
2299
if revision is not None \
2300
and len(revision) > 0 and revision[0].get_branch():
2301
location = revision[0].get_branch()
2804
2302
else:
2805
file_ids.append(file_id)
2806
filter_by_dir = filter_by_dir or (
2807
kind in ['directory', 'tree-reference'])
2808
else:
2809
# log everything
2810
# FIXME ? log the current subdir only RBC 20060203
2811
if revision is not None \
2812
and len(revision) > 0 and revision[0].get_branch():
2813
location = revision[0].get_branch()
2814
else:
2815
location = '.'
2816
dir, relpath = controldir.ControlDir.open_containing(location)
2817
b = dir.open_branch()
2818
self.add_cleanup(b.lock_read().unlock)
2819
rev1, rev2 = _get_revision_range(revision, b, self.name())
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
2828
# Decide on the type of delta & diff filtering to use
2829
# TODO: add an --all-files option to make this configurable & consistent
2830
if not verbose:
2831
delta_type = None
2832
else:
2833
delta_type = 'full'
2834
if not show_diff:
2835
diff_type = None
2836
elif file_ids:
2837
diff_type = 'partial'
2838
else:
2839
diff_type = 'full'
2840
2841
# Build the log formatter
2842
if log_format is None:
2843
log_format = log.log_formatter_registry.get_default(b)
2844
# Make a non-encoding output to include the diffs - bug 328007
2845
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2846
lf = log_format(show_ids=show_ids, to_file=self.outf,
2847
to_exact_file=unencoded_output,
2848
show_timezone=timezone,
2849
delta_format=get_verbosity_level(),
2850
levels=levels,
2851
show_advice=levels is None,
2852
author_list_handler=authors)
2853
2854
# Choose the algorithm for doing the logging. It's annoying
2855
# having multiple code paths like this but necessary until
2856
# the underlying repository format is faster at generating
2857
# deltas or can provide everything we need from the indices.
2858
# The default algorithm - match-using-deltas - works for
2859
# multiple files and directories and is faster for small
2860
# amounts of history (200 revisions say). However, it's too
2861
# slow for logging a single file in a repository with deep
2862
# history, i.e. > 10K revisions. In the spirit of "do no
2863
# evil when adding features", we continue to use the
2864
# original algorithm - per-file-graph - for the "single
2865
# file that isn't a directory without showing a delta" case.
2866
partial_history = revision and b.repository._format.supports_chks
2867
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2868
or delta_type or partial_history)
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
2882
# Build the LogRequest and execute it
2883
if len(file_ids) == 0:
2884
file_ids = None
2885
rqst = make_log_request_dict(
2886
direction=direction, specific_fileids=file_ids,
2887
start_revision=rev1, end_revision=rev2, limit=limit,
2888
message_search=message, delta_type=delta_type,
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
)
2893
Logger(b, rqst).show(lf)
2303
location = '.'
2304
dir, relpath = bzrdir.BzrDir.open_containing(location)
2305
b = dir.open_branch()
2306
b.lock_read()
2307
rev1, rev2 = _get_revision_range(revision, b, self.name())
2308
2309
# Decide on the type of delta & diff filtering to use
2310
# TODO: add an --all-files option to make this configurable & consistent
2311
if not verbose:
2312
delta_type = None
2313
else:
2314
delta_type = 'full'
2315
if not show_diff:
2316
diff_type = None
2317
elif file_ids:
2318
diff_type = 'partial'
2319
else:
2320
diff_type = 'full'
2321
2322
# Build the log formatter
2323
if log_format is None:
2324
log_format = log.log_formatter_registry.get_default(b)
2325
lf = log_format(show_ids=show_ids, to_file=self.outf,
2326
show_timezone=timezone,
2327
delta_format=get_verbosity_level(),
2328
levels=levels,
2329
show_advice=levels is None)
2330
2331
# Choose the algorithm for doing the logging. It's annoying
2332
# having multiple code paths like this but necessary until
2333
# the underlying repository format is faster at generating
2334
# deltas or can provide everything we need from the indices.
2335
# The default algorithm - match-using-deltas - works for
2336
# multiple files and directories and is faster for small
2337
# amounts of history (200 revisions say). However, it's too
2338
# slow for logging a single file in a repository with deep
2339
# history, i.e. > 10K revisions. In the spirit of "do no
2340
# evil when adding features", we continue to use the
2341
# original algorithm - per-file-graph - for the "single
2342
# file that isn't a directory without showing a delta" case.
2343
partial_history = revision and b.repository._format.supports_chks
2344
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2345
or delta_type or partial_history)
2346
2347
# Build the LogRequest and execute it
2348
if len(file_ids) == 0:
2349
file_ids = None
2350
rqst = make_log_request_dict(
2351
direction=direction, specific_fileids=file_ids,
2352
start_revision=rev1, end_revision=rev2, limit=limit,
2353
message_search=message, delta_type=delta_type,
2354
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2355
Logger(b, rqst).show(lf)
2356
finally:
2357
if b is not None:
2358
b.unlock()
2894
2359
2895
2360
2896
2361
def _get_revision_range(revisionspec_list, branch, command_name):
2911
2376
# b is taken from revision[0].get_branch(), and
2912
2377
# show_log will use its revision_history. Having
2913
2378
# different branches will lead to weird behaviors.
2914
raise errors.BzrCommandError(gettext(
2379
raise errors.BzrCommandError(
2915
2380
"bzr %s doesn't accept two revisions in different"
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)
2381
" branches." % command_name)
2382
rev1 = start_spec.in_history(branch)
2922
2383
# Avoid loading all of history when we know a missing
2923
2384
# end of range means the last revision ...
2924
2385
if end_spec.spec is None:
2927
2388
else:
2928
2389
rev2 = end_spec.in_history(branch)
2929
2390
else:
2930
raise errors.BzrCommandError(gettext(
2931
'bzr %s --revision takes one or two values.') % command_name)
2391
raise errors.BzrCommandError(
2392
'bzr %s --revision takes one or two values.' % command_name)
2932
2393
return rev1, rev2
2933
2394
2934
2395
2953
2414
2954
2415
2955
2416
class cmd_touching_revisions(Command):
2956
__doc__ = """Return revision-ids which affected a particular file.
2417
"""Return revision-ids which affected a particular file.
2957
2418
2958
2419
A more user-friendly interface is "bzr log FILE".
2959
2420
"""
2966
2427
tree, relpath = WorkingTree.open_containing(filename)
2967
2428
file_id = tree.path2id(relpath)
2968
2429
b = tree.branch
2969
self.add_cleanup(b.lock_read().unlock)
2970
touching_revs = log.find_touching_revisions(b, file_id)
2971
for revno, revision_id, what in touching_revs:
2972
self.outf.write("%6d %s\n" % (revno, what))
2430
b.lock_read()
2431
try:
2432
touching_revs = log.find_touching_revisions(b, file_id)
2433
for revno, revision_id, what in touching_revs:
2434
self.outf.write("%6d %s\n" % (revno, what))
2435
finally:
2436
b.unlock()
2973
2437
2974
2438
2975
2439
class cmd_ls(Command):
2976
__doc__ = """List files in a tree.
2440
"""List files in a tree.
2977
2441
"""
2978
2442
2979
2443
_see_also = ['status', 'cat']
2985
2449
help='Recurse into subdirectories.'),
2986
2450
Option('from-root',
2987
2451
help='Print paths relative to the root of the branch.'),
2988
Option('unknown', short_name='u',
2989
help='Print unknown files.'),
2452
Option('unknown', help='Print unknown files.'),
2990
2453
Option('versioned', help='Print versioned files.',
2991
2454
short_name='V'),
2992
Option('ignored', short_name='i',
2993
help='Print ignored files.'),
2994
Option('kind', short_name='k',
2455
Option('ignored', help='Print ignored files.'),
2456
Option('null',
2457
help='Write an ascii NUL (\\0) separator '
2458
'between files rather than a newline.'),
2459
Option('kind',
2995
2460
help='List entries of a particular kind: file, directory, symlink.',
2996
2461
type=unicode),
2997
'null',
2998
2462
'show-ids',
2999
'directory',
3000
2463
]
3001
2464
@display_command
3002
2465
def run(self, revision=None, verbose=False,
3003
2466
recursive=False, from_root=False,
3004
2467
unknown=False, versioned=False, ignored=False,
3005
null=False, kind=None, show_ids=False, path=None, directory=None):
2468
null=False, kind=None, show_ids=False, path=None):
3006
2469
3007
2470
if kind and kind not in ('file', 'directory', 'symlink'):
3008
raise errors.BzrCommandError(gettext('invalid kind specified'))
2471
raise errors.BzrCommandError('invalid kind specified')
3009
2472
3010
2473
if verbose and null:
3011
raise errors.BzrCommandError(gettext('Cannot set both --verbose and --null'))
2474
raise errors.BzrCommandError('Cannot set both --verbose and --null')
3012
2475
all = not (unknown or versioned or ignored)
3013
2476
3014
2477
selection = {'I':ignored, '?':unknown, 'V':versioned}
3017
2480
fs_path = '.'
3018
2481
else:
3019
2482
if from_root:
3020
raise errors.BzrCommandError(gettext('cannot specify both --from-root'
3021
' and PATH'))
2483
raise errors.BzrCommandError('cannot specify both --from-root'
2484
' and PATH')
3022
2485
fs_path = path
3023
tree, branch, relpath = \
3024
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2486
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2487
fs_path)
3025
2488
3026
2489
# Calculate the prefix to use
3027
2490
prefix = None
3028
2491
if from_root:
3029
2492
if relpath:
3030
2493
prefix = relpath + '/'
3031
elif fs_path != '.' and not fs_path.endswith('/'):
2494
elif fs_path != '.':
3032
2495
prefix = fs_path + '/'
3033
2496
3034
2497
if revision is not None or tree is None:
3040
2503
if view_files:
3041
2504
apply_view = True
3042
2505
view_str = views.view_display_str(view_files)
3043
note(gettext("Ignoring files outside view. View is %s") % view_str)
3044
3045
self.add_cleanup(tree.lock_read().unlock)
3046
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
3047
from_dir=relpath, recursive=recursive):
3048
# Apply additional masking
3049
if not all and not selection[fc]:
3050
continue
3051
if kind is not None and fkind != kind:
3052
continue
3053
if apply_view:
3054
try:
3055
if relpath:
3056
fullpath = osutils.pathjoin(relpath, fp)
3057
else:
3058
fullpath = fp
3059
views.check_path_in_view(tree, fullpath)
3060
except errors.FileOutsideView:
3061
continue
3062
3063
# Output the entry
3064
if prefix:
3065
fp = osutils.pathjoin(prefix, fp)
3066
kindch = entry.kind_character()
3067
outstring = fp + kindch
3068
ui.ui_factory.clear_term()
3069
if verbose:
3070
outstring = '%-8s %s' % (fc, outstring)
3071
if show_ids and fid is not None:
3072
outstring = "%-50s %s" % (outstring, fid)
3073
self.outf.write(outstring + '\n')
3074
elif null:
3075
self.outf.write(fp + '\0')
3076
if show_ids:
3077
if fid is not None:
3078
self.outf.write(fid)
3079
self.outf.write('\0')
3080
self.outf.flush()
3081
else:
3082
if show_ids:
3083
if fid is not None:
3084
my_id = fid
3085
else:
3086
my_id = ''
3087
self.outf.write('%-50s %s\n' % (outstring, my_id))
3088
else:
2506
note("Ignoring files outside view. View is %s" % view_str)
2507
2508
tree.lock_read()
2509
try:
2510
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2511
from_dir=relpath, recursive=recursive):
2512
# Apply additional masking
2513
if not all and not selection[fc]:
2514
continue
2515
if kind is not None and fkind != kind:
2516
continue
2517
if apply_view:
2518
try:
2519
if relpath:
2520
fullpath = osutils.pathjoin(relpath, fp)
2521
else:
2522
fullpath = fp
2523
views.check_path_in_view(tree, fullpath)
2524
except errors.FileOutsideView:
2525
continue
2526
2527
# Output the entry
2528
if prefix:
2529
fp = osutils.pathjoin(prefix, fp)
2530
kindch = entry.kind_character()
2531
outstring = fp + kindch
2532
ui.ui_factory.clear_term()
2533
if verbose:
2534
outstring = '%-8s %s' % (fc, outstring)
2535
if show_ids and fid is not None:
2536
outstring = "%-50s %s" % (outstring, fid)
3089
2537
self.outf.write(outstring + '\n')
2538
elif null:
2539
self.outf.write(fp + '\0')
2540
if show_ids:
2541
if fid is not None:
2542
self.outf.write(fid)
2543
self.outf.write('\0')
2544
self.outf.flush()
2545
else:
2546
if show_ids:
2547
if fid is not None:
2548
my_id = fid
2549
else:
2550
my_id = ''
2551
self.outf.write('%-50s %s\n' % (outstring, my_id))
2552
else:
2553
self.outf.write(outstring + '\n')
2554
finally:
2555
tree.unlock()
3090
2556
3091
2557
3092
2558
class cmd_unknowns(Command):
3093
__doc__ = """List unknown files.
2559
"""List unknown files.
3094
2560
"""
3095
2561
3096
2562
hidden = True
3097
2563
_see_also = ['ls']
3098
takes_options = ['directory']
3099
2564
3100
2565
@display_command
3101
def run(self, directory=u'.'):
3102
for f in WorkingTree.open_containing(directory)[0].unknowns():
2566
def run(self):
2567
for f in WorkingTree.open_containing(u'.')[0].unknowns():
3103
2568
self.outf.write(osutils.quotefn(f) + '\n')
3104
2569
3105
2570
3106
2571
class cmd_ignore(Command):
3107
__doc__ = """Ignore specified files or patterns.
2572
"""Ignore specified files or patterns.
3108
2573
3109
2574
See ``bzr help patterns`` for details on the syntax of patterns.
3110
2575
3111
If a .bzrignore file does not exist, the ignore command
3112
will create one and add the specified files or patterns to the newly
3113
created file. The ignore command will also automatically add the
3114
.bzrignore file to be versioned. Creating a .bzrignore file without
3115
the use of the ignore command will require an explicit add command.
3116
3117
2576
To remove patterns from the ignore list, edit the .bzrignore file.
3118
2577
After adding, editing or deleting that file either indirectly by
3119
2578
using this command or directly by using an editor, be sure to commit
3120
2579
it.
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
3128
Patterns prefixed with '!' are exceptions to ignore patterns and take
3129
precedence over regular ignores. Such exceptions are used to specify
3130
files that should be versioned which would otherwise be ignored.
3131
3132
Patterns prefixed with '!!' act as regular ignore patterns, but have
3133
precedence over the '!' exception patterns.
3134
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.
2580
2581
Note: ignore patterns containing shell wildcards must be quoted from
2582
the shell on Unix.
3142
2583
3143
2584
:Examples:
3144
2585
Ignore the top level Makefile::
3145
2586
3146
2587
bzr ignore ./Makefile
3147
2588
3148
Ignore .class files in all directories...::
2589
Ignore class files in all directories::
3149
2590
3150
2591
bzr ignore "*.class"
3151
2592
3152
...but do not ignore "special.class"::
3153
3154
bzr ignore "!special.class"
3155
3156
Ignore files whose name begins with the "#" character::
3157
3158
bzr ignore "RE:^#"
3159
3160
2593
Ignore .o files under the lib directory::
3161
2594
3162
2595
bzr ignore "lib/**/*.o"
3168
2601
Ignore everything but the "debian" toplevel directory::
3169
2602
3170
2603
bzr ignore "RE:(?!debian/).*"
3171
3172
Ignore everything except the "local" toplevel directory,
3173
but always ignore autosave files ending in ~, even under local/::
3174
3175
bzr ignore "*"
3176
bzr ignore "!./local"
3177
bzr ignore "!!*~"
3178
2604
"""
3179
2605
3180
2606
_see_also = ['status', 'ignored', 'patterns']
3181
2607
takes_args = ['name_pattern*']
3182
takes_options = ['directory',
3183
Option('default-rules',
3184
help='Display the default ignore rules that bzr uses.')
2608
takes_options = [
2609
Option('old-default-rules',
2610
help='Write out the ignore rules bzr < 0.9 always used.')
3185
2611
]
3186
2612
3187
def run(self, name_pattern_list=None, default_rules=None,
3188
directory=u'.'):
2613
def run(self, name_pattern_list=None, old_default_rules=None):
3189
2614
from bzrlib import ignores
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)
2615
if old_default_rules is not None:
2616
# dump the rules and exit
2617
for pattern in ignores.OLD_DEFAULTS:
2618
print pattern
3194
2619
return
3195
2620
if not name_pattern_list:
3196
raise errors.BzrCommandError(gettext("ignore requires at least one "
3197
"NAME_PATTERN or --default-rules."))
2621
raise errors.BzrCommandError("ignore requires at least one "
2622
"NAME_PATTERN or --old-default-rules")
3198
2623
name_pattern_list = [globbing.normalize_pattern(p)
3199
2624
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('')
3212
2625
for name_pattern in name_pattern_list:
3213
2626
if (name_pattern[0] == '/' or
3214
2627
(len(name_pattern) > 1 and name_pattern[1] == ':')):
3215
raise errors.BzrCommandError(gettext(
3216
"NAME_PATTERN should not be an absolute path"))
3217
tree, relpath = WorkingTree.open_containing(directory)
2628
raise errors.BzrCommandError(
2629
"NAME_PATTERN should not be an absolute path")
2630
tree, relpath = WorkingTree.open_containing(u'.')
3218
2631
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
3219
2632
ignored = globbing.Globster(name_pattern_list)
3220
2633
matches = []
3221
self.add_cleanup(tree.lock_read().unlock)
2634
tree.lock_read()
3222
2635
for entry in tree.list_files():
3223
2636
id = entry[3]
3224
2637
if id is not None:
3225
2638
filename = entry[0]
3226
2639
if ignored.match(filename):
3227
matches.append(filename)
2640
matches.append(filename.encode('utf-8'))
2641
tree.unlock()
3228
2642
if len(matches) > 0:
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),))
2643
print "Warning: the following files are version controlled and" \
2644
" match your ignore pattern:\n%s" \
2645
"\nThese files will continue to be version controlled" \
2646
" unless you 'bzr remove' them." % ("\n".join(matches),)
3233
2647
3234
2648
3235
2649
class cmd_ignored(Command):
3236
__doc__ = """List ignored files and the patterns that matched them.
2650
"""List ignored files and the patterns that matched them.
3237
2651
3238
2652
List all the ignored files and the ignore pattern that caused the file to
3239
2653
be ignored.
3245
2659
3246
2660
encoding_type = 'replace'
3247
2661
_see_also = ['ignore', 'ls']
3248
takes_options = ['directory']
3249
2662
3250
2663
@display_command
3251
def run(self, directory=u'.'):
3252
tree = WorkingTree.open_containing(directory)[0]
3253
self.add_cleanup(tree.lock_read().unlock)
3254
for path, file_class, kind, file_id, entry in tree.list_files():
3255
if file_class != 'I':
3256
continue
3257
## XXX: Slightly inefficient since this was already calculated
3258
pat = tree.is_ignored(path)
3259
self.outf.write('%-50s %s\n' % (path, pat))
2664
def run(self):
2665
tree = WorkingTree.open_containing(u'.')[0]
2666
tree.lock_read()
2667
try:
2668
for path, file_class, kind, file_id, entry in tree.list_files():
2669
if file_class != 'I':
2670
continue
2671
## XXX: Slightly inefficient since this was already calculated
2672
pat = tree.is_ignored(path)
2673
self.outf.write('%-50s %s\n' % (path, pat))
2674
finally:
2675
tree.unlock()
3260
2676
3261
2677
3262
2678
class cmd_lookup_revision(Command):
3263
__doc__ = """Lookup the revision-id from a revision-number
2679
"""Lookup the revision-id from a revision-number
3264
2680
3265
2681
:Examples:
3266
2682
bzr lookup-revision 33
3267
2683
"""
3268
2684
hidden = True
3269
2685
takes_args = ['revno']
3270
takes_options = ['directory']
3271
2686
3272
2687
@display_command
3273
def run(self, revno, directory=u'.'):
2688
def run(self, revno):
3274
2689
try:
3275
2690
revno = int(revno)
3276
2691
except ValueError:
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)
2692
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2693
2694
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
3281
2695
3282
2696
3283
2697
class cmd_export(Command):
3284
__doc__ = """Export current or past revision to a destination directory or archive.
2698
"""Export current or past revision to a destination directory or archive.
3285
2699
3286
2700
If no revision is specified this exports the last committed revision.
3287
2701
3308
2722
zip .zip
3309
2723
================= =========================
3310
2724
"""
3311
encoding = 'exact'
3312
2725
takes_args = ['dest', 'branch_or_subdir?']
3313
takes_options = ['directory',
2726
takes_options = [
3314
2727
Option('format',
3315
2728
help="Type of file to export to.",
3316
2729
type=unicode),
3320
2733
Option('root',
3321
2734
type=str,
3322
2735
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.'),
3329
2736
]
3330
2737
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
3331
root=None, filters=False, per_file_timestamps=False, uncommitted=False,
3332
directory=u'.'):
2738
root=None, filters=False):
3333
2739
from bzrlib.export import export
3334
2740
3335
2741
if branch_or_subdir is 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
2742
tree = WorkingTree.open_containing(u'.')[0]
2743
b = tree.branch
2744
subdir = None
3348
2745
else:
3349
export_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2746
b, subdir = Branch.open_containing(branch_or_subdir)
2747
tree = None
2748
2749
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
3350
2750
try:
3351
export(export_tree, dest, format, root, subdir, filtered=filters,
3352
per_file_timestamps=per_file_timestamps)
2751
export(rev_tree, dest, format, root, subdir, filtered=filters)
3353
2752
except errors.NoSuchExportFormat, e:
3354
raise errors.BzrCommandError(
3355
gettext('Unsupported export format: %s') % e.format)
2753
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
3356
2754
3357
2755
3358
2756
class cmd_cat(Command):
3359
__doc__ = """Write the contents of a file as of a given revision to standard output.
2757
"""Write the contents of a file as of a given revision to standard output.
3360
2758
3361
2759
If no revision is nominated, the last revision is used.
3362
2760
3365
2763
"""
3366
2764
3367
2765
_see_also = ['ls']
3368
takes_options = ['directory',
2766
takes_options = [
3369
2767
Option('name-from-revision', help='The path name in the old tree.'),
3370
2768
Option('filters', help='Apply content filters to display the '
3371
2769
'convenience form.'),
3376
2774
3377
2775
@display_command
3378
2776
def run(self, filename, revision=None, name_from_revision=False,
3379
filters=False, directory=None):
2777
filters=False):
3380
2778
if revision is not None and len(revision) != 1:
3381
raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
3382
" one revision specifier"))
2779
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2780
" one revision specifier")
3383
2781
tree, branch, relpath = \
3384
_open_directory_or_containing_tree_or_branch(filename, directory)
3385
self.add_cleanup(branch.lock_read().unlock)
3386
return self._run(tree, branch, relpath, filename, revision,
3387
name_from_revision, filters)
2782
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2783
branch.lock_read()
2784
try:
2785
return self._run(tree, branch, relpath, filename, revision,
2786
name_from_revision, filters)
2787
finally:
2788
branch.unlock()
3388
2789
3389
2790
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
3390
2791
filtered):
3391
2792
if tree is None:
3392
2793
tree = b.basis_tree()
3393
2794
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
3394
self.add_cleanup(rev_tree.lock_read().unlock)
3395
2795
3396
2796
old_file_id = rev_tree.path2id(relpath)
3397
2797
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.
3402
2798
if name_from_revision:
3403
2799
# Try in revision if requested
3404
2800
if old_file_id is None:
3405
raise errors.BzrCommandError(gettext(
3406
"{0!r} is not present in revision {1}").format(
2801
raise errors.BzrCommandError(
2802
"%r is not present in revision %s" % (
3407
2803
filename, rev_tree.get_revision_id()))
3408
2804
else:
3409
actual_file_id = old_file_id
2805
content = rev_tree.get_file_text(old_file_id)
3410
2806
else:
3411
2807
cur_file_id = tree.path2id(relpath)
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(
2808
found = False
2809
if cur_file_id is not None:
2810
# Then try with the actual file id
2811
try:
2812
content = rev_tree.get_file_text(cur_file_id)
2813
found = True
2814
except errors.NoSuchId:
2815
# The actual file id didn't exist at that time
2816
pass
2817
if not found and old_file_id is not None:
2818
# Finally try with the old file id
2819
content = rev_tree.get_file_text(old_file_id)
2820
found = True
2821
if not found:
2822
# Can't be found anywhere
2823
raise errors.BzrCommandError(
2824
"%r is not present in revision %s" % (
3419
2825
filename, rev_tree.get_revision_id()))
3420
2826
if filtered:
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)
2827
from bzrlib.filters import (
2828
ContentFilterContext,
2829
filtered_output_bytes,
2830
)
2831
filters = rev_tree._content_filter_stack(relpath)
2832
chunks = content.splitlines(True)
2833
content = filtered_output_bytes(chunks, filters,
2834
ContentFilterContext(relpath, rev_tree))
2835
self.outf.writelines(content)
3425
2836
else:
3426
content = rev_tree.get_file_text(actual_file_id)
3427
self.cleanup_now()
3428
self.outf.write(content)
2837
self.outf.write(content)
3429
2838
3430
2839
3431
2840
class cmd_local_time_offset(Command):
3432
__doc__ = """Show the offset in seconds from GMT to local time."""
2841
"""Show the offset in seconds from GMT to local time."""
3433
2842
hidden = True
3434
2843
@display_command
3435
2844
def run(self):
3436
self.outf.write("%s\n" % osutils.local_time_offset())
2845
print osutils.local_time_offset()
3437
2846
3438
2847
3439
2848
3440
2849
class cmd_commit(Command):
3441
__doc__ = """Commit changes into a new revision.
2850
"""Commit changes into a new revision.
3442
2851
3443
2852
An explanatory message needs to be given for each commit. This is
3444
2853
often done by using the --message option (getting the message from the
3492
2901
to trigger updates to external systems like bug trackers. The --fixes
3493
2902
option can be used to record the association between a revision and
3494
2903
one or more bugs. See ``bzr help bugs`` for details.
2904
2905
A selective commit may fail in some cases where the committed
2906
tree would be invalid. Consider::
2907
2908
bzr init foo
2909
mkdir foo/bar
2910
bzr add foo/bar
2911
bzr commit foo -m "committing foo"
2912
bzr mv foo/bar foo/baz
2913
mkdir foo/bar
2914
bzr add foo/bar
2915
bzr commit foo/bar -m "committing bar but not baz"
2916
2917
In the example above, the last commit will fail by design. This gives
2918
the user the opportunity to decide whether they want to commit the
2919
rename at the same time, separately first, or not at all. (As a general
2920
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3495
2921
"""
2922
# TODO: Run hooks on tree to-be-committed, and after commit.
2923
2924
# TODO: Strict commit that fails if there are deleted files.
2925
# (what does "deleted files" mean ??)
2926
2927
# TODO: Give better message for -s, --summary, used by tla people
2928
2929
# XXX: verbose currently does nothing
3496
2930
3497
2931
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
3498
2932
takes_args = ['selected*']
3512
2946
Option('strict',
3513
2947
help="Refuse to commit if there are unknown "
3514
2948
"files in the working tree."),
3515
Option('commit-time', type=str,
3516
help="Manually set a commit time using commit date "
3517
"format, e.g. '2009-10-10 08:00:00 +0100'."),
3518
2949
ListOption('fixes', type=str,
3519
2950
help="Mark a bug as being fixed by this revision "
3520
2951
"(see \"bzr help bugs\")."),
3527
2958
"the master branch until a normal commit "
3528
2959
"is performed."
3529
2960
),
3530
Option('show-diff', short_name='p',
3531
help='When no message is supplied, show the diff along'
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.'),
2961
Option('show-diff',
2962
help='When no message is supplied, show the diff along'
2963
' with the status summary in the message editor.'),
3537
2964
]
3538
2965
aliases = ['ci', 'checkin']
3539
2966
3540
2967
def _iter_bug_fix_urls(self, fixes, branch):
3541
default_bugtracker = None
3542
2968
# Configure the properties for bug fixing attributes.
3543
2969
for fixed_bug in fixes:
3544
2970
tokens = fixed_bug.split(':')
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(
2971
if len(tokens) != 2:
2972
raise errors.BzrCommandError(
3561
2973
"Invalid bug %s. Must be in the form of 'tracker:id'. "
3562
2974
"See \"bzr help bugs\" for more information on this "
3563
"feature.\nCommit refused.") % fixed_bug)
3564
else:
3565
tag, bug_id = tokens
2975
"feature.\nCommit refused." % fixed_bug)
2976
tag, bug_id = tokens
3566
2977
try:
3567
2978
yield bugtracker.get_bug_url(tag, branch, bug_id)
3568
2979
except errors.UnknownBugTrackerAbbreviation:
3569
raise errors.BzrCommandError(gettext(
3570
'Unrecognized bug %s. Commit refused.') % fixed_bug)
2980
raise errors.BzrCommandError(
2981
'Unrecognized bug %s. Commit refused.' % fixed_bug)
3571
2982
except errors.MalformedBugIdentifier, e:
3572
raise errors.BzrCommandError(gettext(
3573
"%s\nCommit refused.") % (str(e),))
2983
raise errors.BzrCommandError(
2984
"%s\nCommit refused." % (str(e),))
3574
2985
3575
2986
def run(self, message=None, file=None, verbose=False, selected_list=None,
3576
2987
unchanged=False, strict=False, local=False, fixes=None,
3577
author=None, show_diff=False, exclude=None, commit_time=None,
3578
lossy=False):
2988
author=None, show_diff=False, exclude=None):
3579
2989
from bzrlib.errors import (
3580
2990
PointlessCommit,
3581
2991
ConflictsInTree,
3584
2994
from bzrlib.msgeditor import (
3585
2995
edit_commit_message_encoded,
3586
2996
generate_commit_message_template,
3587
make_commit_message_template_encoded,
3588
set_commit_message,
2997
make_commit_message_template_encoded
3589
2998
)
3590
2999
3591
commit_stamp = offset = None
3592
if commit_time is not None:
3593
try:
3594
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3595
except ValueError, e:
3596
raise errors.BzrCommandError(gettext(
3597
"Could not parse --commit-time: " + str(e)))
3000
# TODO: Need a blackbox test for invoking the external editor; may be
3001
# slightly problematic to run this cross-platform.
3002
3003
# TODO: do more checks that the commit will succeed before
3004
# spending the user's valuable time typing a commit message.
3598
3005
3599
3006
properties = {}
3600
3007
3601
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3008
tree, selected_list = tree_files(selected_list)
3602
3009
if selected_list == ['']:
3603
3010
# workaround - commit of root of tree should be exactly the same
3604
3011
# as just default commit in that tree, and succeed even though
3615
3022
if local and not tree.branch.get_bound_location():
3616
3023
raise errors.LocalRequiresBoundBranch()
3617
3024
3618
if message is not None:
3619
try:
3620
file_exists = osutils.lexists(message)
3621
except UnicodeError:
3622
# The commit message contains unicode characters that can't be
3623
# represented in the filesystem encoding, so that can't be a
3624
# file.
3625
file_exists = False
3626
if file_exists:
3627
warning_msg = (
3628
'The commit message is a file name: "%(f)s".\n'
3629
'(use --file "%(f)s" to take commit message from that file)'
3630
% { 'f': message })
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"))
3638
3639
3025
def get_message(commit_obj):
3640
3026
"""Callback to get commit message"""
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,
3027
my_message = message
3028
if my_message is None and not file:
3029
t = make_commit_message_template_encoded(tree,
3653
3030
selected_list, diff=show_diff,
3654
3031
output_encoding=osutils.get_user_encoding())
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 \"\"."))
3032
start_message = generate_commit_message_template(commit_obj)
3033
my_message = edit_commit_message_encoded(t,
3034
start_message=start_message)
3035
if my_message is None:
3036
raise errors.BzrCommandError("please specify a commit"
3037
" message with either --message or --file")
3038
elif my_message and file:
3039
raise errors.BzrCommandError(
3040
"please specify either --message or --file")
3041
if file:
3042
my_message = codecs.open(file, 'rt',
3043
osutils.get_user_encoding()).read()
3044
if my_message == "":
3045
raise errors.BzrCommandError("empty commit message specified")
3673
3046
return my_message
3674
3047
3675
3048
# The API permits a commit with a filter of [] to mean 'select nothing'
3681
3054
specific_files=selected_list,
3682
3055
allow_pointless=unchanged, strict=strict, local=local,
3683
3056
reporter=None, verbose=verbose, revprops=properties,
3684
authors=author, timestamp=commit_stamp,
3685
timezone=offset,
3686
exclude=tree.safe_relpath_files(exclude),
3687
lossy=lossy)
3057
authors=author,
3058
exclude=safe_relpath_files(tree, exclude))
3688
3059
except PointlessCommit:
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."))
3060
# FIXME: This should really happen before the file is read in;
3061
# perhaps prepare the commit; get the message; then actually commit
3062
raise errors.BzrCommandError("No changes to commit."
3063
" Use --unchanged to commit anyhow.")
3692
3064
except ConflictsInTree:
3693
raise errors.BzrCommandError(gettext('Conflicts detected in working '
3065
raise errors.BzrCommandError('Conflicts detected in working '
3694
3066
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3695
' resolve.'))
3067
' resolve.')
3696
3068
except StrictCommitFailed:
3697
raise errors.BzrCommandError(gettext("Commit refused because there are"
3698
" unknown files in the working tree."))
3069
raise errors.BzrCommandError("Commit refused because there are"
3070
" unknown files in the working tree.")
3699
3071
except errors.BoundBranchOutOfDate, e:
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
3072
raise errors.BzrCommandError(str(e) + "\n"
3073
'To commit to master branch, run update and then commit.\n'
3074
'You can also pass --local to commit to continue working '
3075
'disconnected.')
3705
3076
3706
3077
3707
3078
class cmd_check(Command):
3708
__doc__ = """Validate working tree structure, branch consistency and repository history.
3079
"""Validate working tree structure, branch consistency and repository history.
3709
3080
3710
3081
This command checks various invariants about branch and repository storage
3711
3082
to detect data corruption or bzr bugs.
3775
3146
3776
3147
3777
3148
class cmd_upgrade(Command):
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/.
3149
"""Upgrade branch storage to current format.
3150
3151
The check command or bzr developers may sometimes advise you to run
3152
this command. When the default format has changed you may also be warned
3153
during other operations to upgrade.
3808
3154
"""
3809
3155
3810
_see_also = ['check', 'reconcile', 'formats']
3156
_see_also = ['check']
3811
3157
takes_args = ['url?']
3812
3158
takes_options = [
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
]
3159
RegistryOption('format',
3160
help='Upgrade to a specific format. See "bzr help'
3161
' formats" for details.',
3162
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3163
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3164
value_switches=True, title='Branch format'),
3165
]
3824
3166
3825
def run(self, url='.', format=None, clean=False, dry_run=False):
3167
def run(self, url='.', format=None):
3826
3168
from bzrlib.upgrade import upgrade
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
3169
upgrade(url, format)
3834
3170
3835
3171
3836
3172
class cmd_whoami(Command):
3837
__doc__ = """Show or set bzr user id.
3173
"""Show or set bzr user id.
3838
3174
3839
3175
:Examples:
3840
3176
Show the email of the current user::
3845
3181
3846
3182
bzr whoami "Frank Chu <fchu@example.com>"
3847
3183
"""
3848
takes_options = [ 'directory',
3849
Option('email',
3184
takes_options = [ Option('email',
3850
3185
help='Display email address only.'),
3851
3186
Option('branch',
3852
3187
help='Set identity for the current branch instead of '
3856
3191
encoding_type = 'replace'
3857
3192
3858
3193
@display_command
3859
def run(self, email=False, branch=False, name=None, directory=None):
3194
def run(self, email=False, branch=False, name=None):
3860
3195
if name is None:
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')
3196
# use branch if we're inside one; otherwise global config
3197
try:
3198
c = Branch.open_containing('.')[0].get_config()
3199
except errors.NotBranchError:
3200
c = config.GlobalConfig()
3870
3201
if email:
3871
self.outf.write(_mod_config.extract_email_address(identity)
3872
+ '\n')
3202
self.outf.write(c.user_email() + '\n')
3873
3203
else:
3874
self.outf.write(identity + '\n')
3204
self.outf.write(c.username() + '\n')
3875
3205
return
3876
3206
3877
if email:
3878
raise errors.BzrCommandError(gettext("--email can only be used to display existing "
3879
"identity"))
3880
3881
3207
# display a warning if an email address isn't included in the given name.
3882
3208
try:
3883
_mod_config.extract_email_address(name)
3209
config.extract_email_address(name)
3884
3210
except errors.NoEmailInUsername, e:
3885
3211
warning('"%s" does not seem to contain an email address. '
3886
3212
'This is allowed, but not recommended.', name)
3887
3213
3888
3214
# use global config unless --branch given
3889
3215
if branch:
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()
3216
c = Branch.open_containing('.')[0].get_config()
3896
3217
else:
3897
c = _mod_config.GlobalStack()
3898
c.set('email', name)
3218
c = config.GlobalConfig()
3219
c.set_user_option('email', name)
3899
3220
3900
3221
3901
3222
class cmd_nick(Command):
3902
__doc__ = """Print or set the branch nickname.
3223
"""Print or set the branch nickname.
3903
3224
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.
3225
If unset, the tree root directory name is used as the nickname.
3226
To print the current nickname, execute with no argument.
3907
3227
3908
3228
Bound branches use the nickname of its master branch unless it is set
3909
3229
locally.
3911
3231
3912
3232
_see_also = ['info']
3913
3233
takes_args = ['nickname?']
3914
takes_options = ['directory']
3915
def run(self, nickname=None, directory=u'.'):
3916
branch = Branch.open_containing(directory)[0]
3234
def run(self, nickname=None):
3235
branch = Branch.open_containing(u'.')[0]
3917
3236
if nickname is None:
3918
3237
self.printme(branch)
3919
3238
else:
3921
3240
3922
3241
@display_command
3923
3242
def printme(self, branch):
3924
self.outf.write('%s\n' % branch.nick)
3243
print branch.nick
3925
3244
3926
3245
3927
3246
class cmd_alias(Command):
3928
__doc__ = """Set/unset and display aliases.
3247
"""Set/unset and display aliases.
3929
3248
3930
3249
:Examples:
3931
3250
Show the current aliases::
3964
3283
3965
3284
def remove_alias(self, alias_name):
3966
3285
if alias_name is None:
3967
raise errors.BzrCommandError(gettext(
3968
'bzr alias --remove expects an alias to remove.'))
3286
raise errors.BzrCommandError(
3287
'bzr alias --remove expects an alias to remove.')
3969
3288
# If alias is not found, print something like:
3970
3289
# unalias: foo: not found
3971
c = _mod_config.GlobalConfig()
3290
c = config.GlobalConfig()
3972
3291
c.unset_alias(alias_name)
3973
3292
3974
3293
@display_command
3975
3294
def print_aliases(self):
3976
3295
"""Print out the defined aliases in a similar format to bash."""
3977
aliases = _mod_config.GlobalConfig().get_aliases()
3296
aliases = config.GlobalConfig().get_aliases()
3978
3297
for key, value in sorted(aliases.iteritems()):
3979
3298
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3980
3299
3990
3309
3991
3310
def set_alias(self, alias_name, alias_command):
3992
3311
"""Save the alias in the global config."""
3993
c = _mod_config.GlobalConfig()
3312
c = config.GlobalConfig()
3994
3313
c.set_alias(alias_name, alias_command)
3995
3314
3996
3315
3997
3316
class cmd_selftest(Command):
3998
__doc__ = """Run internal test suite.
3317
"""Run internal test suite.
3999
3318
4000
3319
If arguments are given, they are regular expressions that say which tests
4001
3320
should run. Tests matching any expression are run, and other tests are
4028
3347
Tests that need working space on disk use a common temporary directory,
4029
3348
typically inside $TMPDIR or /tmp.
4030
3349
4031
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
4032
into a pdb postmortem session.
4033
4034
The --coverage=DIRNAME global option produces a report with covered code
4035
indicated.
4036
4037
3350
:Examples:
4038
3351
Run only tests relating to 'ignore'::
4039
3352
4048
3361
def get_transport_type(typestring):
4049
3362
"""Parse and return a transport specifier."""
4050
3363
if typestring == "sftp":
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
3364
from bzrlib.transport.sftp import SFTPAbsoluteServer
3365
return SFTPAbsoluteServer
3366
if typestring == "memory":
3367
from bzrlib.transport.memory import MemoryServer
3368
return MemoryServer
3369
if typestring == "fakenfs":
3370
from bzrlib.transport.fakenfs import FakeNFSServer
3371
return FakeNFSServer
4059
3372
msg = "No known transport type %s. Supported types are: sftp\n" %\
4060
3373
(typestring)
4061
3374
raise errors.BzrCommandError(msg)
4072
3385
'throughout the test suite.',
4073
3386
type=get_transport_type),
4074
3387
Option('benchmark',
4075
help='Run the benchmarks rather than selftests.',
4076
hidden=True),
3388
help='Run the benchmarks rather than selftests.'),
4077
3389
Option('lsprof-timed',
4078
3390
help='Generate lsprof output for benchmarked'
4079
3391
' sections of code.'),
4080
Option('lsprof-tests',
4081
help='Generate lsprof output for each test.'),
3392
Option('cache-dir', type=str,
3393
help='Cache intermediate benchmark output in this '
3394
'directory.'),
4082
3395
Option('first',
4083
3396
help='Run all tests, but run specified tests first.',
4084
3397
short_name='f',
4093
3406
Option('randomize', type=str, argname="SEED",
4094
3407
help='Randomize the order of tests using the given'
4095
3408
' seed or "now" for the current time.'),
4096
ListOption('exclude', type=str, argname="PATTERN",
4097
short_name='x',
4098
help='Exclude tests that match this regular'
4099
' expression.'),
3409
Option('exclude', type=str, argname="PATTERN",
3410
short_name='x',
3411
help='Exclude tests that match this regular'
3412
' expression.'),
4100
3413
Option('subunit',
4101
3414
help='Output test progress via subunit.'),
4102
3415
Option('strict', help='Fail on missing dependencies or '
4109
3422
param_name='starting_with', short_name='s',
4110
3423
help=
4111
3424
'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.")
4115
3425
]
4116
3426
encoding_type = 'replace'
4117
3427
4121
3431
4122
3432
def run(self, testspecs_list=None, verbose=False, one=False,
4123
3433
transport=None, benchmark=None,
4124
lsprof_timed=None,
3434
lsprof_timed=None, cache_dir=None,
4125
3435
first=False, list_only=False,
4126
3436
randomize=None, exclude=None, strict=False,
4127
3437
load_list=None, debugflag=None, starting_with=None, subunit=False,
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
3438
parallel=None):
3439
from bzrlib.tests import selftest
3440
import bzrlib.benchmarks as benchmarks
3441
from bzrlib.benchmarks import tree_creator
3442
3443
# Make deprecation warnings visible, unless -Werror is set
3444
symbol_versioning.activate_deprecation_warnings(override=False)
3445
3446
if cache_dir is not None:
3447
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
4141
3448
if testspecs_list is not None:
4142
3449
pattern = '|'.join(testspecs_list)
4143
3450
else:
4146
3453
try:
4147
3454
from bzrlib.tests import SubUnitBzrRunner
4148
3455
except ImportError:
4149
raise errors.BzrCommandError(gettext("subunit not available. subunit "
4150
"needs to be installed to use --subunit."))
3456
raise errors.BzrCommandError("subunit not available. subunit "
3457
"needs to be installed to use --subunit.")
4151
3458
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)
4161
3459
if parallel:
4162
3460
self.additional_selftest_args.setdefault(
4163
3461
'suite_decorators', []).append(parallel)
4164
3462
if benchmark:
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
3463
test_suite_factory = benchmarks.test_suite
3464
# Unless user explicitly asks for quiet, be verbose in benchmarks
3465
verbose = not is_quiet()
3466
# TODO: should possibly lock the history file...
3467
benchfile = open(".perf_history", "at", buffering=1)
4171
3468
else:
4172
exclude_pattern = '(' + '|'.join(exclude) + ')'
4173
if not sync:
4174
self._disable_fsync()
4175
selftest_kwargs = {"verbose": verbose,
4176
"pattern": pattern,
4177
"stop_on_failure": one,
4178
"transport": transport,
4179
"test_suite_factory": test_suite_factory,
4180
"lsprof_timed": lsprof_timed,
4181
"lsprof_tests": lsprof_tests,
4182
"matching_tests_first": first,
4183
"list_only": list_only,
4184
"random_seed": randomize,
4185
"exclude_pattern": exclude_pattern,
4186
"strict": strict,
4187
"load_list": load_list,
4188
"debug_flags": debugflag,
4189
"starting_with": starting_with
4190
}
4191
selftest_kwargs.update(self.additional_selftest_args)
4192
4193
# Make deprecation warnings visible, unless -Werror is set
4194
cleanup = symbol_versioning.activate_deprecation_warnings(
4195
override=False)
3469
test_suite_factory = None
3470
benchfile = None
4196
3471
try:
4197
result = tests.selftest(**selftest_kwargs)
3472
selftest_kwargs = {"verbose": verbose,
3473
"pattern": pattern,
3474
"stop_on_failure": one,
3475
"transport": transport,
3476
"test_suite_factory": test_suite_factory,
3477
"lsprof_timed": lsprof_timed,
3478
"bench_history": benchfile,
3479
"matching_tests_first": first,
3480
"list_only": list_only,
3481
"random_seed": randomize,
3482
"exclude_pattern": exclude,
3483
"strict": strict,
3484
"load_list": load_list,
3485
"debug_flags": debugflag,
3486
"starting_with": starting_with
3487
}
3488
selftest_kwargs.update(self.additional_selftest_args)
3489
result = selftest(**selftest_kwargs)
4198
3490
finally:
4199
cleanup()
3491
if benchfile is not None:
3492
benchfile.close()
4200
3493
return int(not result)
4201
3494
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
4211
3495
4212
3496
class cmd_version(Command):
4213
__doc__ = """Show version of bzr."""
3497
"""Show version of bzr."""
4214
3498
4215
3499
encoding_type = 'replace'
4216
3500
takes_options = [
4227
3511
4228
3512
4229
3513
class cmd_rocks(Command):
4230
__doc__ = """Statement of optimism."""
3514
"""Statement of optimism."""
4231
3515
4232
3516
hidden = True
4233
3517
4234
3518
@display_command
4235
3519
def run(self):
4236
self.outf.write(gettext("It sure does!\n"))
3520
print "It sure does!"
4237
3521
4238
3522
4239
3523
class cmd_find_merge_base(Command):
4240
__doc__ = """Find and print a base revision for merging two branches."""
3524
"""Find and print a base revision for merging two branches."""
4241
3525
# TODO: Options to specify revisions on either side, as if
4242
3526
# merging only part of the history.
4243
3527
takes_args = ['branch', 'other']
4249
3533
4250
3534
branch1 = Branch.open_containing(branch)[0]
4251
3535
branch2 = Branch.open_containing(other)[0]
4252
self.add_cleanup(branch1.lock_read().unlock)
4253
self.add_cleanup(branch2.lock_read().unlock)
4254
last1 = ensure_null(branch1.last_revision())
4255
last2 = ensure_null(branch2.last_revision())
4256
4257
graph = branch1.repository.get_graph(branch2.repository)
4258
base_rev_id = graph.find_unique_lca(last1, last2)
4259
4260
self.outf.write(gettext('merge base is revision %s\n') % base_rev_id)
3536
branch1.lock_read()
3537
try:
3538
branch2.lock_read()
3539
try:
3540
last1 = ensure_null(branch1.last_revision())
3541
last2 = ensure_null(branch2.last_revision())
3542
3543
graph = branch1.repository.get_graph(branch2.repository)
3544
base_rev_id = graph.find_unique_lca(last1, last2)
3545
3546
print 'merge base is revision %s' % base_rev_id
3547
finally:
3548
branch2.unlock()
3549
finally:
3550
branch1.unlock()
4261
3551
4262
3552
4263
3553
class cmd_merge(Command):
4264
__doc__ = """Perform a three-way merge.
3554
"""Perform a three-way merge.
4265
3555
4266
3556
The source of the merge can be specified either in the form of a branch,
4267
3557
or in the form of a path to a file containing a merge directive generated
4268
3558
with bzr send. If neither is specified, the default is the upstream branch
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.
3559
or the branch most recently merged using --remember.
3560
3561
When merging a branch, by default the tip will be merged. To pick a different
3562
revision, pass --revision. If you specify two values, the first will be used as
3563
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3564
available revisions, like this is commonly referred to as "cherrypicking".
3565
3566
Revision numbers are always relative to the branch being merged.
3567
3568
By default, bzr will try to merge in all new work from the other
3569
branch, automatically determining an appropriate base. If this
3570
fails, you may need to give an explicit base.
4290
3571
4291
3572
Merge will do its best to combine the changes in two branches, but there
4292
3573
are some kinds of problems only a human can fix. When it encounters those,
4293
3574
it will mark a conflict. A conflict means that you need to fix something,
4294
before you can commit.
3575
before you should commit.
4295
3576
4296
3577
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
4297
3578
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.
3579
If there is no default branch set, the first merge will set it. After
3580
that, you can omit the branch to use the default. To change the
3581
default, use --remember. The value will only be saved if the remote
3582
location can be accessed.
4302
3583
4303
3584
The results of the merge are placed into the destination working
4304
3585
directory, where they can be reviewed (with bzr diff), tested, and then
4305
3586
committed to record the result of the merge.
4306
3587
4307
3588
merge refuses to run if there are any uncommitted changes, unless
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
4311
merge revision which has more than two parents.
4312
4313
If one would like to merge changes from the working tree of the other
4314
branch without merging any committed revisions, the --uncommitted option
4315
can be given.
3589
--force is given.
4316
3590
4317
3591
To select only some changes to merge, use "merge -i", which will prompt
4318
3592
you to apply each diff hunk and file change, similar to "shelve".
4319
3593
4320
3594
:Examples:
4321
To merge all new revisions from bzr.dev::
3595
To merge the latest revision from bzr.dev::
4322
3596
4323
3597
bzr merge ../bzr.dev
4324
3598
4330
3604
4331
3605
bzr merge -r 81..82 ../bzr.dev
4332
3606
4333
To apply a merge directive contained in /tmp/merge::
3607
To apply a merge directive contained in /tmp/merge:
4334
3608
4335
3609
bzr merge /tmp/merge
4336
4337
To create a merge revision with three parents from two branches
4338
feature1a and feature1b:
4339
4340
bzr merge ../feature1a
4341
bzr merge ../feature1b --force
4342
bzr commit -m 'revision with three parents'
4343
3610
"""
4344
3611
4345
3612
encoding_type = 'exact'
4361
3628
' completely merged into the source, pull from the'
4362
3629
' source rather than merging. When this happens,'
4363
3630
' you do not need to commit the result.'),
4364
custom_help('directory',
3631
Option('directory',
4365
3632
help='Branch to merge into, '
4366
'rather than the one containing the working directory.'),
3633
'rather than the one containing the working directory.',
3634
short_name='d',
3635
type=unicode,
3636
),
4367
3637
Option('preview', help='Instead of merging, show a diff of the'
4368
3638
' merge.'),
4369
3639
Option('interactive', help='Select changes interactively.',
4371
3641
]
4372
3642
4373
3643
def run(self, location=None, revision=None, force=False,
4374
merge_type=None, show_base=False, reprocess=None, remember=None,
3644
merge_type=None, show_base=False, reprocess=None, remember=False,
4375
3645
uncommitted=False, pull=False,
4376
3646
directory=None,
4377
3647
preview=False,
4385
3655
merger = None
4386
3656
allow_pending = True
4387
3657
verified = 'inapplicable'
4388
4389
3658
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'))
4393
3659
3660
# die as quickly as possible if there are uncommitted changes
4394
3661
try:
4395
3662
basis_tree = tree.revision_tree(tree.last_revision())
4396
3663
except errors.NoSuchRevision:
4397
3664
basis_tree = tree.basis_tree()
4398
4399
# die as quickly as possible if there are uncommitted changes
4400
3665
if not force:
4401
if tree.has_changes():
3666
if tree.has_changes(basis_tree):
4402
3667
raise errors.UncommittedChanges(tree)
4403
3668
4404
3669
view_info = _get_view_info_for_change_reporter(tree)
4405
3670
change_reporter = delta._ChangeReporter(
4406
3671
unversioned_filter=tree.is_ignored, view_info=view_info)
4407
pb = ui.ui_factory.nested_progress_bar()
4408
self.add_cleanup(pb.finished)
4409
self.add_cleanup(tree.lock_write().unlock)
4410
if location is not None:
4411
try:
4412
mergeable = bundle.read_mergeable_from_url(location,
4413
possible_transports=possible_transports)
4414
except errors.NotABundle:
4415
mergeable = None
3672
cleanups = []
3673
try:
3674
pb = ui.ui_factory.nested_progress_bar()
3675
cleanups.append(pb.finished)
3676
tree.lock_write()
3677
cleanups.append(tree.unlock)
3678
if location is not None:
3679
try:
3680
mergeable = bundle.read_mergeable_from_url(location,
3681
possible_transports=possible_transports)
3682
except errors.NotABundle:
3683
mergeable = None
3684
else:
3685
if uncommitted:
3686
raise errors.BzrCommandError('Cannot use --uncommitted'
3687
' with bundles or merge directives.')
3688
3689
if revision is not None:
3690
raise errors.BzrCommandError(
3691
'Cannot use -r with merge directives or bundles')
3692
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3693
mergeable, pb)
3694
3695
if merger is None and uncommitted:
3696
if revision is not None and len(revision) > 0:
3697
raise errors.BzrCommandError('Cannot use --uncommitted and'
3698
' --revision at the same time.')
3699
merger = self.get_merger_from_uncommitted(tree, location, pb,
3700
cleanups)
3701
allow_pending = False
3702
3703
if merger is None:
3704
merger, allow_pending = self._get_merger_from_branch(tree,
3705
location, revision, remember, possible_transports, pb)
3706
3707
merger.merge_type = merge_type
3708
merger.reprocess = reprocess
3709
merger.show_base = show_base
3710
self.sanity_check_merger(merger)
3711
if (merger.base_rev_id == merger.other_rev_id and
3712
merger.other_rev_id is not None):
3713
note('Nothing to do.')
3714
return 0
3715
if pull:
3716
if merger.interesting_files is not None:
3717
raise errors.BzrCommandError('Cannot pull individual files')
3718
if (merger.base_rev_id == tree.last_revision()):
3719
result = tree.pull(merger.other_branch, False,
3720
merger.other_rev_id)
3721
result.report(self.outf)
3722
return 0
3723
merger.check_basis(False)
3724
if preview:
3725
return self._do_preview(merger, cleanups)
3726
elif interactive:
3727
return self._do_interactive(merger, cleanups)
4416
3728
else:
4417
if uncommitted:
4418
raise errors.BzrCommandError(gettext('Cannot use --uncommitted'
4419
' with bundles or merge directives.'))
4420
4421
if revision is not None:
4422
raise errors.BzrCommandError(gettext(
4423
'Cannot use -r with merge directives or bundles'))
4424
merger, verified = _mod_merge.Merger.from_mergeable(tree,
4425
mergeable, None)
4426
4427
if merger is None and uncommitted:
4428
if revision is not None and len(revision) > 0:
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)
4432
allow_pending = False
4433
4434
if merger is None:
4435
merger, allow_pending = self._get_merger_from_branch(tree,
4436
location, revision, remember, possible_transports, None)
4437
4438
merger.merge_type = merge_type
4439
merger.reprocess = reprocess
4440
merger.show_base = show_base
4441
self.sanity_check_merger(merger)
4442
if (merger.base_rev_id == merger.other_rev_id and
4443
merger.other_rev_id is not None):
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.'))
4452
return 0
4453
if pull and not preview:
4454
if merger.interesting_files is not None:
4455
raise errors.BzrCommandError(gettext('Cannot pull individual files'))
4456
if (merger.base_rev_id == tree.last_revision()):
4457
result = tree.pull(merger.other_branch, False,
4458
merger.other_rev_id)
4459
result.report(self.outf)
4460
return 0
4461
if merger.this_basis is None:
4462
raise errors.BzrCommandError(gettext(
4463
"This branch has no commits."
4464
" (perhaps you would prefer 'bzr pull')"))
4465
if preview:
4466
return self._do_preview(merger)
4467
elif interactive:
4468
return self._do_interactive(merger)
4469
else:
4470
return self._do_merge(merger, change_reporter, allow_pending,
4471
verified)
4472
4473
def _get_preview(self, merger):
3729
return self._do_merge(merger, change_reporter, allow_pending,
3730
verified)
3731
finally:
3732
for cleanup in reversed(cleanups):
3733
cleanup()
3734
3735
def _get_preview(self, merger, cleanups):
4474
3736
tree_merger = merger.make_merger()
4475
3737
tt = tree_merger.make_preview_transform()
4476
self.add_cleanup(tt.finalize)
3738
cleanups.append(tt.finalize)
4477
3739
result_tree = tt.get_preview_tree()
4478
3740
return result_tree
4479
3741
4480
def _do_preview(self, merger):
3742
def _do_preview(self, merger, cleanups):
4481
3743
from bzrlib.diff import show_diff_trees
4482
result_tree = self._get_preview(merger)
4483
path_encoding = osutils.get_diff_header_encoding()
3744
result_tree = self._get_preview(merger, cleanups)
4484
3745
show_diff_trees(merger.this_tree, result_tree, self.outf,
4485
old_label='', new_label='',
4486
path_encoding=path_encoding)
3746
old_label='', new_label='')
4487
3747
4488
3748
def _do_merge(self, merger, change_reporter, allow_pending, verified):
4489
3749
merger.change_reporter = change_reporter
4497
3757
else:
4498
3758
return 0
4499
3759
4500
def _do_interactive(self, merger):
3760
def _do_interactive(self, merger, cleanups):
4501
3761
"""Perform an interactive merge.
4502
3762
4503
3763
This works by generating a preview tree of the merge, then using
4505
3765
and the preview tree.
4506
3766
"""
4507
3767
from bzrlib import shelf_ui
4508
result_tree = self._get_preview(merger)
3768
result_tree = self._get_preview(merger, cleanups)
4509
3769
writer = bzrlib.option.diff_writer_registry.get()
4510
3770
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
4511
3771
reporter=shelf_ui.ApplyReporter(),
4512
3772
diff_writer=writer(sys.stdout))
4513
try:
4514
shelver.run()
4515
finally:
4516
shelver.finalize()
3773
shelver.run()
4517
3774
4518
3775
def sanity_check_merger(self, merger):
4519
3776
if (merger.show_base and
4520
3777
not merger.merge_type is _mod_merge.Merge3Merger):
4521
raise errors.BzrCommandError(gettext("Show-base is not supported for this"
4522
" merge type. %s") % merger.merge_type)
3778
raise errors.BzrCommandError("Show-base is not supported for this"
3779
" merge type. %s" % merger.merge_type)
4523
3780
if merger.reprocess is None:
4524
3781
if merger.show_base:
4525
3782
merger.reprocess = False
4527
3784
# Use reprocess if the merger supports it
4528
3785
merger.reprocess = merger.merge_type.supports_reprocess
4529
3786
if merger.reprocess and not merger.merge_type.supports_reprocess:
4530
raise errors.BzrCommandError(gettext("Conflict reduction is not supported"
4531
" for merge type %s.") %
3787
raise errors.BzrCommandError("Conflict reduction is not supported"
3788
" for merge type %s." %
4532
3789
merger.merge_type)
4533
3790
if merger.reprocess and merger.show_base:
4534
raise errors.BzrCommandError(gettext("Cannot do conflict reduction and"
4535
" show base."))
3791
raise errors.BzrCommandError("Cannot do conflict reduction and"
3792
" show base.")
4536
3793
4537
3794
def _get_merger_from_branch(self, tree, location, revision, remember,
4538
3795
possible_transports, pb):
4565
3822
if other_revision_id is None:
4566
3823
other_revision_id = _mod_revision.ensure_null(
4567
3824
other_branch.last_revision())
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)))):
3825
# Remember where we merge from
3826
if ((remember or tree.branch.get_submit_branch() is None) and
3827
user_location is not None):
4577
3828
tree.branch.set_submit_branch(other_branch.base)
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)
3829
_merge_tags_if_possible(other_branch, tree.branch)
4581
3830
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4582
3831
other_revision_id, base_revision_id, other_branch, base_branch)
4583
3832
if other_path != '':
4587
3836
allow_pending = True
4588
3837
return merger, allow_pending
4589
3838
4590
def get_merger_from_uncommitted(self, tree, location, pb):
3839
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
4591
3840
"""Get a merger for uncommitted changes.
4592
3841
4593
3842
:param tree: The tree the merger should apply to.
4594
3843
:param location: The location containing uncommitted changes.
4595
3844
:param pb: The progress bar to use for showing progress.
3845
:param cleanups: A list of operations to perform to clean up the
3846
temporary directories, unfinalized objects, etc.
4596
3847
"""
4597
3848
location = self._select_branch_location(tree, location)[0]
4598
3849
other_tree, other_path = WorkingTree.open_containing(location)
4642
3893
stored_location_type = "parent"
4643
3894
mutter("%s", stored_location)
4644
3895
if stored_location is None:
4645
raise errors.BzrCommandError(gettext("No location specified or remembered"))
3896
raise errors.BzrCommandError("No location specified or remembered")
4646
3897
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
4647
note(gettext("{0} remembered {1} location {2}").format(verb_string,
4648
stored_location_type, display_url))
3898
note(u"%s remembered %s location %s", verb_string,
3899
stored_location_type, display_url)
4649
3900
return stored_location
4650
3901
4651
3902
4652
3903
class cmd_remerge(Command):
4653
__doc__ = """Redo a merge.
3904
"""Redo a merge.
4654
3905
4655
3906
Use this if you want to try a different merge technique while resolving
4656
3907
conflicts. Some merge techniques are better than others, and remerge
4681
3932
4682
3933
def run(self, file_list=None, merge_type=None, show_base=False,
4683
3934
reprocess=False):
4684
from bzrlib.conflicts import restore
4685
3935
if merge_type is None:
4686
3936
merge_type = _mod_merge.Merge3Merger
4687
tree, file_list = WorkingTree.open_containing_paths(file_list)
4688
self.add_cleanup(tree.lock_write().unlock)
4689
parents = tree.get_parent_ids()
4690
if len(parents) != 2:
4691
raise errors.BzrCommandError(gettext("Sorry, remerge only works after normal"
4692
" merges. Not cherrypicking or"
4693
" multi-merges."))
4694
repository = tree.branch.repository
4695
interesting_ids = None
4696
new_conflicts = []
4697
conflicts = tree.conflicts()
4698
if file_list is not None:
4699
interesting_ids = set()
4700
for filename in file_list:
4701
file_id = tree.path2id(filename)
4702
if file_id is None:
4703
raise errors.NotVersionedError(filename)
4704
interesting_ids.add(file_id)
4705
if tree.kind(file_id) != "directory":
4706
continue
3937
tree, file_list = tree_files(file_list)
3938
tree.lock_write()
3939
try:
3940
parents = tree.get_parent_ids()
3941
if len(parents) != 2:
3942
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3943
" merges. Not cherrypicking or"
3944
" multi-merges.")
3945
repository = tree.branch.repository
3946
interesting_ids = None
3947
new_conflicts = []
3948
conflicts = tree.conflicts()
3949
if file_list is not None:
3950
interesting_ids = set()
3951
for filename in file_list:
3952
file_id = tree.path2id(filename)
3953
if file_id is None:
3954
raise errors.NotVersionedError(filename)
3955
interesting_ids.add(file_id)
3956
if tree.kind(file_id) != "directory":
3957
continue
4707
3958
4708
# FIXME: Support nested trees
4709
for name, ie in tree.root_inventory.iter_entries(file_id):
4710
interesting_ids.add(ie.file_id)
4711
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4712
else:
4713
# Remerge only supports resolving contents conflicts
4714
allowed_conflicts = ('text conflict', 'contents conflict')
4715
restore_files = [c.path for c in conflicts
4716
if c.typestring in allowed_conflicts]
4717
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4718
tree.set_conflicts(ConflictList(new_conflicts))
4719
if file_list is not None:
4720
restore_files = file_list
4721
for filename in restore_files:
3959
for name, ie in tree.inventory.iter_entries(file_id):
3960
interesting_ids.add(ie.file_id)
3961
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3962
else:
3963
# Remerge only supports resolving contents conflicts
3964
allowed_conflicts = ('text conflict', 'contents conflict')
3965
restore_files = [c.path for c in conflicts
3966
if c.typestring in allowed_conflicts]
3967
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3968
tree.set_conflicts(ConflictList(new_conflicts))
3969
if file_list is not None:
3970
restore_files = file_list
3971
for filename in restore_files:
3972
try:
3973
restore(tree.abspath(filename))
3974
except errors.NotConflicted:
3975
pass
3976
# Disable pending merges, because the file texts we are remerging
3977
# have not had those merges performed. If we use the wrong parents
3978
# list, we imply that the working tree text has seen and rejected
3979
# all the changes from the other tree, when in fact those changes
3980
# have not yet been seen.
3981
pb = ui.ui_factory.nested_progress_bar()
3982
tree.set_parent_ids(parents[:1])
4722
3983
try:
4723
restore(tree.abspath(filename))
4724
except errors.NotConflicted:
4725
pass
4726
# Disable pending merges, because the file texts we are remerging
4727
# have not had those merges performed. If we use the wrong parents
4728
# list, we imply that the working tree text has seen and rejected
4729
# all the changes from the other tree, when in fact those changes
4730
# have not yet been seen.
4731
tree.set_parent_ids(parents[:1])
4732
try:
4733
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4734
merger.interesting_ids = interesting_ids
4735
merger.merge_type = merge_type
4736
merger.show_base = show_base
4737
merger.reprocess = reprocess
4738
conflicts = merger.do_merge()
3984
merger = _mod_merge.Merger.from_revision_ids(pb,
3985
tree, parents[1])
3986
merger.interesting_ids = interesting_ids
3987
merger.merge_type = merge_type
3988
merger.show_base = show_base
3989
merger.reprocess = reprocess
3990
conflicts = merger.do_merge()
3991
finally:
3992
tree.set_parent_ids(parents)
3993
pb.finished()
4739
3994
finally:
4740
tree.set_parent_ids(parents)
3995
tree.unlock()
4741
3996
if conflicts > 0:
4742
3997
return 1
4743
3998
else:
4745
4000
4746
4001
4747
4002
class cmd_revert(Command):
4748
__doc__ = """\
4749
Set files in the working tree back to the contents of a previous revision.
4003
"""Revert files to a previous revision.
4750
4004
4751
4005
Giving a list of files will revert only those files. Otherwise, all files
4752
4006
will be reverted. If the revision is not specified with '--revision', the
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.
4007
last committed revision is used.
4756
4008
4757
4009
To remove only some changes, without reverting to a prior version, use
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.
4010
merge instead. For example, "merge . --revision -2..-3" will remove the
4011
changes introduced by -2, without affecting the changes introduced by -1.
4012
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4765
4013
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.
4014
By default, any files that have been manually changed will be backed up
4015
first. (Files changed only by merge are not backed up.) Backup files have
4016
'.~#~' appended to their name, where # is a number.
4770
4017
4771
4018
When you provide files, you can use their current pathname or the pathname
4772
4019
from the target revision. So you can use revert to "undelete" a file by
4773
4020
name. If you name a directory, all the contents of that directory will be
4774
4021
reverted.
4775
4022
4776
If you have newly added files since the target revision, they will be
4777
removed. If the files to be removed have been changed, backups will be
4778
created as above. Directories containing unknown files will not be
4779
deleted.
4023
Any files that have been newly added since that revision will be deleted,
4024
with a backup kept if appropriate. Directories containing unknown files
4025
will not be deleted.
4780
4026
4781
The working tree contains a list of revisions that have been merged but
4782
not yet committed. These revisions will be included as additional parents
4783
of the next commit. Normally, using revert clears that list as well as
4784
reverting the files. If any files are specified, revert leaves the list
4785
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4786
.`` in the tree root to revert all files but keep the recorded merges,
4787
and ``bzr revert --forget-merges`` to clear the pending merge list without
4027
The working tree contains a list of pending merged revisions, which will
4028
be included as parents in the next commit. Normally, revert clears that
4029
list as well as reverting the files. If any files are specified, revert
4030
leaves the pending merge list alone and reverts only the files. Use "bzr
4031
revert ." in the tree root to revert all files but keep the merge record,
4032
and "bzr revert --forget-merges" to clear the pending merge list without
4788
4033
reverting any files.
4789
4790
Using "bzr revert --forget-merges", it is possible to apply all of the
4791
changes from a branch in a single revision. To do this, perform the merge
4792
as desired. Then doing revert with the "--forget-merges" option will keep
4793
the content of the tree as it was, but it will clear the list of pending
4794
merges. The next commit will then contain all of the changes that are
4795
present in the other branch, but without any other parent revisions.
4796
Because this technique forgets where these changes originated, it may
4797
cause additional conflicts on later merges involving the same source and
4798
target branches.
4799
4034
"""
4800
4035
4801
_see_also = ['cat', 'export', 'merge', 'shelve']
4036
_see_also = ['cat', 'export']
4802
4037
takes_options = [
4803
4038
'revision',
4804
4039
Option('no-backup', "Do not save backups of reverted files."),
4809
4044
4810
4045
def run(self, revision=None, no_backup=False, file_list=None,
4811
4046
forget_merges=None):
4812
tree, file_list = WorkingTree.open_containing_paths(file_list)
4813
self.add_cleanup(tree.lock_tree_write().unlock)
4814
if forget_merges:
4815
tree.set_parent_ids(tree.get_parent_ids()[:1])
4816
else:
4817
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4047
tree, file_list = tree_files(file_list)
4048
tree.lock_write()
4049
try:
4050
if forget_merges:
4051
tree.set_parent_ids(tree.get_parent_ids()[:1])
4052
else:
4053
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4054
finally:
4055
tree.unlock()
4818
4056
4819
4057
@staticmethod
4820
4058
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4821
4059
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4822
tree.revert(file_list, rev_tree, not no_backup, None,
4823
report_changes=True)
4060
pb = ui.ui_factory.nested_progress_bar()
4061
try:
4062
tree.revert(file_list, rev_tree, not no_backup, pb,
4063
report_changes=True)
4064
finally:
4065
pb.finished()
4824
4066
4825
4067
4826
4068
class cmd_assert_fail(Command):
4827
__doc__ = """Test reporting of assertion failures"""
4069
"""Test reporting of assertion failures"""
4828
4070
# intended just for use in testing
4829
4071
4830
4072
hidden = True
4834
4076
4835
4077
4836
4078
class cmd_help(Command):
4837
__doc__ = """Show help on a command or other topic.
4079
"""Show help on a command or other topic.
4838
4080
"""
4839
4081
4840
4082
_see_also = ['topics']
4853
4095
4854
4096
4855
4097
class cmd_shell_complete(Command):
4856
__doc__ = """Show appropriate completions for context.
4098
"""Show appropriate completions for context.
4857
4099
4858
4100
For a list of all available commands, say 'bzr shell-complete'.
4859
4101
"""
4863
4105
4864
4106
@display_command
4865
4107
def run(self, context=None):
4866
from bzrlib import shellcomplete
4108
import shellcomplete
4867
4109
shellcomplete.shellcomplete(context)
4868
4110
4869
4111
4870
4112
class cmd_missing(Command):
4871
__doc__ = """Show unmerged/unpulled revisions between two branches.
4113
"""Show unmerged/unpulled revisions between two branches.
4872
4114
4873
4115
OTHER_BRANCH may be local or remote.
4874
4116
4875
4117
To filter on a range of revisions, you can use the command -r begin..end
4876
4118
-r revision requests a specific revision, -r ..end or -r begin.. are
4877
4119
also valid.
4878
4879
:Exit values:
4880
1 - some missing revisions
4881
0 - no missing revisions
4882
4120
4883
4121
:Examples:
4884
4122
4905
4143
_see_also = ['merge', 'pull']
4906
4144
takes_args = ['other_branch?']
4907
4145
takes_options = [
4908
'directory',
4909
4146
Option('reverse', 'Reverse the order of revisions.'),
4910
4147
Option('mine-only',
4911
4148
'Display changes in the local branch only.'),
4923
4160
type=_parse_revision_str,
4924
4161
help='Filter on local branch revisions (inclusive). '
4925
4162
'See "help revisionspec" for details.'),
4926
Option('include-merged',
4163
Option('include-merges',
4927
4164
'Show all revisions in addition to the mainline ones.'),
4928
Option('include-merges', hidden=True,
4929
help='Historical alias for --include-merged.'),
4930
4165
]
4931
4166
encoding_type = 'replace'
4932
4167
4935
4170
theirs_only=False,
4936
4171
log_format=None, long=False, short=False, line=False,
4937
4172
show_ids=False, verbose=False, this=False, other=False,
4938
include_merged=None, revision=None, my_revision=None,
4939
directory=u'.',
4940
include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4173
include_merges=False, revision=None, my_revision=None):
4941
4174
from bzrlib.missing import find_unmerged, iter_log_revisions
4942
4175
def message(s):
4943
4176
if not is_quiet():
4944
4177
self.outf.write(s)
4945
4178
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
4961
4179
if this:
4962
4180
mine_only = this
4963
4181
if other:
4971
4189
elif theirs_only:
4972
4190
restrict = 'remote'
4973
4191
4974
local_branch = Branch.open_containing(directory)[0]
4975
self.add_cleanup(local_branch.lock_read().unlock)
4976
4192
local_branch = Branch.open_containing(u".")[0]
4977
4193
parent = local_branch.get_parent()
4978
4194
if other_branch is None:
4979
4195
other_branch = parent
4980
4196
if other_branch is None:
4981
raise errors.BzrCommandError(gettext("No peer location known"
4982
" or specified."))
4197
raise errors.BzrCommandError("No peer location known"
4198
" or specified.")
4983
4199
display_url = urlutils.unescape_for_display(parent,
4984
4200
self.outf.encoding)
4985
message(gettext("Using saved parent location: {0}\n").format(
4986
display_url))
4201
message("Using saved parent location: "
4202
+ display_url + "\n")
4987
4203
4988
4204
remote_branch = Branch.open(other_branch)
4989
4205
if remote_branch.base == local_branch.base:
4990
4206
remote_branch = local_branch
4991
else:
4992
self.add_cleanup(remote_branch.lock_read().unlock)
4993
4207
4994
4208
local_revid_range = _revision_range_to_revid_range(
4995
4209
_get_revision_range(my_revision, local_branch,
4999
4213
_get_revision_range(revision,
5000
4214
remote_branch, self.name()))
5001
4215
5002
local_extra, remote_extra = find_unmerged(
5003
local_branch, remote_branch, restrict,
5004
backward=not reverse,
5005
include_merged=include_merged,
5006
local_revid_range=local_revid_range,
5007
remote_revid_range=remote_revid_range)
5008
5009
if log_format is None:
5010
registry = log.log_formatter_registry
5011
log_format = registry.get_default(local_branch)
5012
lf = log_format(to_file=self.outf,
5013
show_ids=show_ids,
5014
show_timezone='original')
5015
5016
status_code = 0
5017
if local_extra and not theirs_only:
5018
message(ngettext("You have %d extra revision:\n",
5019
"You have %d extra revisions:\n",
5020
len(local_extra)) %
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()
5025
for revision in iter_log_revisions(local_extra,
5026
local_branch.repository,
5027
verbose,
5028
rev_tag_dict):
5029
lf.log_revision(revision)
5030
printed_local = True
5031
status_code = 1
5032
else:
5033
printed_local = False
5034
5035
if remote_extra and not mine_only:
5036
if printed_local is True:
5037
message("\n\n\n")
5038
message(ngettext("You are missing %d revision:\n",
5039
"You are missing %d revisions:\n",
5040
len(remote_extra)) %
5041
len(remote_extra))
5042
if remote_branch.supports_tags():
5043
rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
5044
for revision in iter_log_revisions(remote_extra,
5045
remote_branch.repository,
5046
verbose,
5047
rev_tag_dict):
5048
lf.log_revision(revision)
5049
status_code = 1
5050
5051
if mine_only and not local_extra:
5052
# We checked local, and found nothing extra
5053
message(gettext('This branch has no new revisions.\n'))
5054
elif theirs_only and not remote_extra:
5055
# We checked remote, and found nothing extra
5056
message(gettext('Other branch has no new revisions.\n'))
5057
elif not (mine_only or theirs_only or local_extra or
5058
remote_extra):
5059
# We checked both branches, and neither one had extra
5060
# revisions
5061
message(gettext("Branches are up to date.\n"))
5062
self.cleanup_now()
4216
local_branch.lock_read()
4217
try:
4218
remote_branch.lock_read()
4219
try:
4220
local_extra, remote_extra = find_unmerged(
4221
local_branch, remote_branch, restrict,
4222
backward=not reverse,
4223
include_merges=include_merges,
4224
local_revid_range=local_revid_range,
4225
remote_revid_range=remote_revid_range)
4226
4227
if log_format is None:
4228
registry = log.log_formatter_registry
4229
log_format = registry.get_default(local_branch)
4230
lf = log_format(to_file=self.outf,
4231
show_ids=show_ids,
4232
show_timezone='original')
4233
4234
status_code = 0
4235
if local_extra and not theirs_only:
4236
message("You have %d extra revision(s):\n" %
4237
len(local_extra))
4238
for revision in iter_log_revisions(local_extra,
4239
local_branch.repository,
4240
verbose):
4241
lf.log_revision(revision)
4242
printed_local = True
4243
status_code = 1
4244
else:
4245
printed_local = False
4246
4247
if remote_extra and not mine_only:
4248
if printed_local is True:
4249
message("\n\n\n")
4250
message("You are missing %d revision(s):\n" %
4251
len(remote_extra))
4252
for revision in iter_log_revisions(remote_extra,
4253
remote_branch.repository,
4254
verbose):
4255
lf.log_revision(revision)
4256
status_code = 1
4257
4258
if mine_only and not local_extra:
4259
# We checked local, and found nothing extra
4260
message('This branch is up to date.\n')
4261
elif theirs_only and not remote_extra:
4262
# We checked remote, and found nothing extra
4263
message('Other branch is up to date.\n')
4264
elif not (mine_only or theirs_only or local_extra or
4265
remote_extra):
4266
# We checked both branches, and neither one had extra
4267
# revisions
4268
message("Branches are up to date.\n")
4269
finally:
4270
remote_branch.unlock()
4271
finally:
4272
local_branch.unlock()
5063
4273
if not status_code and parent is None and other_branch is not None:
5064
self.add_cleanup(local_branch.lock_write().unlock)
5065
# handle race conditions - a parent might be set while we run.
5066
if local_branch.get_parent() is None:
5067
local_branch.set_parent(remote_branch.base)
4274
local_branch.lock_write()
4275
try:
4276
# handle race conditions - a parent might be set while we run.
4277
if local_branch.get_parent() is None:
4278
local_branch.set_parent(remote_branch.base)
4279
finally:
4280
local_branch.unlock()
5068
4281
return status_code
5069
4282
5070
4283
5071
4284
class cmd_pack(Command):
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
"""
4285
"""Compress the data within a repository."""
5089
4286
5090
4287
_see_also = ['repositories']
5091
4288
takes_args = ['branch_or_repo?']
5092
takes_options = [
5093
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
5094
]
5095
4289
5096
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
5097
dir = controldir.ControlDir.open_containing(branch_or_repo)[0]
4290
def run(self, branch_or_repo='.'):
4291
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
5098
4292
try:
5099
4293
branch = dir.open_branch()
5100
4294
repository = branch.repository
5101
4295
except errors.NotBranchError:
5102
4296
repository = dir.open_repository()
5103
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4297
repository.pack()
5104
4298
5105
4299
5106
4300
class cmd_plugins(Command):
5107
__doc__ = """List the installed plugins.
4301
"""List the installed plugins.
5108
4302
5109
4303
This command displays the list of installed plugins including
5110
4304
version of plugin and a short description of each.
5117
4311
adding new commands, providing additional network transports and
5118
4312
customizing log output.
5119
4313
5120
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
5121
for further information on plugins including where to find them and how to
5122
install them. Instructions are also provided there on how to write new
5123
plugins using the Python programming language.
4314
See the Bazaar web site, http://bazaar-vcs.org, for further
4315
information on plugins including where to find them and how to
4316
install them. Instructions are also provided there on how to
4317
write new plugins using the Python programming language.
5124
4318
"""
5125
4319
takes_options = ['verbose']
5126
4320
5127
4321
@display_command
5128
4322
def run(self, verbose=False):
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)))
4323
import bzrlib.plugin
4324
from inspect import getdoc
4325
result = []
4326
for name, plugin in bzrlib.plugin.plugins().items():
4327
version = plugin.__version__
4328
if version == 'unknown':
4329
version = ''
4330
name_ver = '%s %s' % (name, version)
4331
d = getdoc(plugin.module)
4332
if d:
4333
doc = d.split('\n')[0]
4334
else:
4335
doc = '(no description)'
4336
result.append((name_ver, doc, plugin.path()))
4337
for name_ver, doc, path in sorted(result):
4338
print name_ver
4339
print ' ', doc
4340
if verbose:
4341
print ' ', path
4342
print
5133
4343
5134
4344
5135
4345
class cmd_testament(Command):
5136
__doc__ = """Show testament (signing-form) of a revision."""
4346
"""Show testament (signing-form) of a revision."""
5137
4347
takes_options = [
5138
4348
'revision',
5139
4349
Option('long', help='Produce long-format testament.'),
5140
4350
Option('strict',
5141
4351
help='Produce a strict-format testament.')]
5142
4352
takes_args = ['branch?']
5143
encoding_type = 'exact'
5144
4353
@display_command
5145
4354
def run(self, branch=u'.', revision=None, long=False, strict=False):
5146
4355
from bzrlib.testament import Testament, StrictTestament
5152
4361
b = Branch.open_containing(branch)[0]
5153
4362
else:
5154
4363
b = Branch.open(branch)
5155
self.add_cleanup(b.lock_read().unlock)
5156
if revision is None:
5157
rev_id = b.last_revision()
5158
else:
5159
rev_id = revision[0].as_revision_id(b)
5160
t = testament_class.from_revision(b.repository, rev_id)
5161
if long:
5162
self.outf.writelines(t.as_text_lines())
5163
else:
5164
self.outf.write(t.as_short_text())
4364
b.lock_read()
4365
try:
4366
if revision is None:
4367
rev_id = b.last_revision()
4368
else:
4369
rev_id = revision[0].as_revision_id(b)
4370
t = testament_class.from_revision(b.repository, rev_id)
4371
if long:
4372
sys.stdout.writelines(t.as_text_lines())
4373
else:
4374
sys.stdout.write(t.as_short_text())
4375
finally:
4376
b.unlock()
5165
4377
5166
4378
5167
4379
class cmd_annotate(Command):
5168
__doc__ = """Show the origin of each line in a file.
4380
"""Show the origin of each line in a file.
5169
4381
5170
4382
This prints out the given file with an annotation on the left side
5171
4383
indicating which revision, author and date introduced the change.
5182
4394
Option('long', help='Show commit date in annotations.'),
5183
4395
'revision',
5184
4396
'show-ids',
5185
'directory',
5186
4397
]
5187
4398
encoding_type = 'exact'
5188
4399
5189
4400
@display_command
5190
4401
def run(self, filename, all=False, long=False, revision=None,
5191
show_ids=False, directory=None):
5192
from bzrlib.annotate import (
5193
annotate_file_tree,
5194
)
4402
show_ids=False):
4403
from bzrlib.annotate import annotate_file, annotate_file_tree
5195
4404
wt, branch, relpath = \
5196
_open_directory_or_containing_tree_or_branch(filename, directory)
4405
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
5197
4406
if wt is not None:
5198
self.add_cleanup(wt.lock_read().unlock)
5199
else:
5200
self.add_cleanup(branch.lock_read().unlock)
5201
tree = _get_one_revision_tree('annotate', revision, branch=branch)
5202
self.add_cleanup(tree.lock_read().unlock)
5203
if wt is not None and revision is None:
5204
file_id = wt.path2id(relpath)
5205
else:
5206
file_id = tree.path2id(relpath)
5207
if file_id is None:
5208
raise errors.NotVersionedError(filename)
5209
if wt is not None and revision is None:
5210
# If there is a tree and we're not annotating historical
5211
# versions, annotate the working tree's content.
5212
annotate_file_tree(wt, file_id, self.outf, long, all,
5213
show_ids=show_ids)
5214
else:
5215
annotate_file_tree(tree, file_id, self.outf, long, all,
5216
show_ids=show_ids, branch=branch)
4407
wt.lock_read()
4408
else:
4409
branch.lock_read()
4410
try:
4411
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4412
tree.lock_read()
4413
try:
4414
if wt is not None:
4415
file_id = wt.path2id(relpath)
4416
else:
4417
file_id = tree.path2id(relpath)
4418
if file_id is None:
4419
raise errors.NotVersionedError(filename)
4420
file_version = tree.inventory[file_id].revision
4421
if wt is not None and revision is None:
4422
# If there is a tree and we're not annotating historical
4423
# versions, annotate the working tree's content.
4424
annotate_file_tree(wt, file_id, self.outf, long, all,
4425
show_ids=show_ids)
4426
else:
4427
annotate_file(branch, file_version, file_id, long, all,
4428
self.outf, show_ids=show_ids)
4429
finally:
4430
tree.unlock()
4431
finally:
4432
if wt is not None:
4433
wt.unlock()
4434
else:
4435
branch.unlock()
5217
4436
5218
4437
5219
4438
class cmd_re_sign(Command):
5220
__doc__ = """Create a digital signature for an existing revision."""
4439
"""Create a digital signature for an existing revision."""
5221
4440
# TODO be able to replace existing ones.
5222
4441
5223
4442
hidden = True # is this right ?
5224
4443
takes_args = ['revision_id*']
5225
takes_options = ['directory', 'revision']
4444
takes_options = ['revision']
5226
4445
5227
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4446
def run(self, revision_id_list=None, revision=None):
5228
4447
if revision_id_list is not None and revision is not None:
5229
raise errors.BzrCommandError(gettext('You can only supply one of revision_id or --revision'))
4448
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
5230
4449
if revision_id_list is None and revision is None:
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)
5234
return self._run(b, revision_id_list, revision)
4450
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4451
b = WorkingTree.open_containing(u'.')[0].branch
4452
b.lock_write()
4453
try:
4454
return self._run(b, revision_id_list, revision)
4455
finally:
4456
b.unlock()
5235
4457
5236
4458
def _run(self, b, revision_id_list, revision):
5237
4459
import bzrlib.gpg as gpg
5238
gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
4460
gpg_strategy = gpg.GPGStrategy(b.get_config())
5239
4461
if revision_id_list is not None:
5240
4462
b.repository.start_write_group()
5241
4463
try:
5266
4488
if to_revid is None:
5267
4489
to_revno = b.revno()
5268
4490
if from_revno is None or to_revno is None:
5269
raise errors.BzrCommandError(gettext('Cannot sign a range of non-revision-history revisions'))
4491
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
5270
4492
b.repository.start_write_group()
5271
4493
try:
5272
4494
for revno in range(from_revno, to_revno + 1):
5278
4500
else:
5279
4501
b.repository.commit_write_group()
5280
4502
else:
5281
raise errors.BzrCommandError(gettext('Please supply either one revision, or a range.'))
4503
raise errors.BzrCommandError('Please supply either one revision, or a range.')
5282
4504
5283
4505
5284
4506
class cmd_bind(Command):
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.
4507
"""Convert the current branch into a checkout of the supplied branch.
5287
4508
5288
4509
Once converted into a checkout, commits must succeed on the master branch
5289
4510
before they will be applied to the local branch.
5290
4511
5291
4512
Bound branches use the nickname of its master branch unless it is set
5292
locally, in which case binding will update the local nickname to be
4513
locally, in which case binding will update the the local nickname to be
5293
4514
that of the master.
5294
4515
"""
5295
4516
5296
4517
_see_also = ['checkouts', 'unbind']
5297
4518
takes_args = ['location?']
5298
takes_options = ['directory']
4519
takes_options = []
5299
4520
5300
def run(self, location=None, directory=u'.'):
5301
b, relpath = Branch.open_containing(directory)
4521
def run(self, location=None):
4522
b, relpath = Branch.open_containing(u'.')
5302
4523
if location is None:
5303
4524
try:
5304
4525
location = b.get_old_bound_location()
5305
4526
except errors.UpgradeRequired:
5306
raise errors.BzrCommandError(gettext('No location supplied. '
5307
'This format does not remember old locations.'))
4527
raise errors.BzrCommandError('No location supplied. '
4528
'This format does not remember old locations.')
5308
4529
else:
5309
4530
if location is None:
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'))
4531
raise errors.BzrCommandError('No location supplied and no '
4532
'previous location known')
5317
4533
b_other = Branch.open(location)
5318
4534
try:
5319
4535
b.bind(b_other)
5320
4536
except errors.DivergedBranches:
5321
raise errors.BzrCommandError(gettext('These branches have diverged.'
5322
' Try merging, and then bind again.'))
4537
raise errors.BzrCommandError('These branches have diverged.'
4538
' Try merging, and then bind again.')
5323
4539
if b.get_config().has_explicit_nickname():
5324
4540
b.nick = b_other.nick
5325
4541
5326
4542
5327
4543
class cmd_unbind(Command):
5328
__doc__ = """Convert the current checkout into a regular branch.
4544
"""Convert the current checkout into a regular branch.
5329
4545
5330
4546
After unbinding, the local branch is considered independent and subsequent
5331
4547
commits will be local only.
5333
4549
5334
4550
_see_also = ['checkouts', 'bind']
5335
4551
takes_args = []
5336
takes_options = ['directory']
4552
takes_options = []
5337
4553
5338
def run(self, directory=u'.'):
5339
b, relpath = Branch.open_containing(directory)
4554
def run(self):
4555
b, relpath = Branch.open_containing(u'.')
5340
4556
if not b.unbind():
5341
raise errors.BzrCommandError(gettext('Local branch is not bound'))
4557
raise errors.BzrCommandError('Local branch is not bound')
5342
4558
5343
4559
5344
4560
class cmd_uncommit(Command):
5345
__doc__ = """Remove the last committed revision.
4561
"""Remove the last committed revision.
5346
4562
5347
4563
--verbose will print out what is being removed.
5348
4564
--dry-run will go through all the motions, but not actually
5365
4581
takes_options = ['verbose', 'revision',
5366
4582
Option('dry-run', help='Don\'t actually make changes.'),
5367
4583
Option('force', help='Say yes to all questions.'),
5368
Option('keep-tags',
5369
help='Keep tags that point to removed revisions.'),
5370
4584
Option('local',
5371
4585
help="Only remove the commits from the local branch"
5372
4586
" when in a checkout."
5376
4590
aliases = []
5377
4591
encoding_type = 'replace'
5378
4592
5379
def run(self, location=None, dry_run=False, verbose=False,
5380
revision=None, force=False, local=False, keep_tags=False):
4593
def run(self, location=None,
4594
dry_run=False, verbose=False,
4595
revision=None, force=False, local=False):
5381
4596
if location is None:
5382
4597
location = u'.'
5383
control, relpath = controldir.ControlDir.open_containing(location)
4598
control, relpath = bzrdir.BzrDir.open_containing(location)
5384
4599
try:
5385
4600
tree = control.open_workingtree()
5386
4601
b = tree.branch
5389
4604
b = control.open_branch()
5390
4605
5391
4606
if tree is not None:
5392
self.add_cleanup(tree.lock_write().unlock)
4607
tree.lock_write()
5393
4608
else:
5394
self.add_cleanup(b.lock_write().unlock)
5395
return self._run(b, tree, dry_run, verbose, revision, force,
5396
local, keep_tags)
4609
b.lock_write()
4610
try:
4611
return self._run(b, tree, dry_run, verbose, revision, force,
4612
local=local)
4613
finally:
4614
if tree is not None:
4615
tree.unlock()
4616
else:
4617
b.unlock()
5397
4618
5398
def _run(self, b, tree, dry_run, verbose, revision, force, local,
5399
keep_tags):
4619
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
5400
4620
from bzrlib.log import log_formatter, show_log
5401
4621
from bzrlib.uncommit import uncommit
5402
4622
5417
4637
rev_id = b.get_rev_id(revno)
5418
4638
5419
4639
if rev_id is None or _mod_revision.is_null(rev_id):
5420
self.outf.write(gettext('No revisions to uncommit.\n'))
4640
self.outf.write('No revisions to uncommit.\n')
5421
4641
return 1
5422
4642
5423
4643
lf = log_formatter('short',
5432
4652
end_revision=last_revno)
5433
4653
5434
4654
if dry_run:
5435
self.outf.write(gettext('Dry-run, pretending to remove'
5436
' the above revisions.\n'))
4655
print 'Dry-run, pretending to remove the above revisions.'
4656
if not force:
4657
val = raw_input('Press <enter> to continue')
5437
4658
else:
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
4659
print 'The above revision(s) will be removed.'
4660
if not force:
4661
val = raw_input('Are you sure [y/N]? ')
4662
if val.lower() not in ('y', 'yes'):
4663
print 'Canceled'
4664
return 0
5447
4665
5448
4666
mutter('Uncommitting from {%s} to {%s}',
5449
4667
last_rev_id, rev_id)
5450
4668
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
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)
4669
revno=revno, local=local)
4670
note('You can restore the old tip by running:\n'
4671
' bzr pull . -r revid:%s', last_rev_id)
5454
4672
5455
4673
5456
4674
class cmd_break_lock(Command):
5457
__doc__ = """Break a dead lock.
5458
5459
This command breaks a lock on a repository, branch, working directory or
5460
config file.
4675
"""Break a dead lock on a repository, branch or working directory.
5461
4676
5462
4677
CAUTION: Locks should only be broken when you are sure that the process
5463
4678
holding the lock has been stopped.
5464
4679
5465
You can get information on what locks are open via the 'bzr info
5466
[location]' command.
4680
You can get information on what locks are open via the 'bzr info' command.
5467
4681
5468
4682
:Examples:
5469
4683
bzr break-lock
5470
bzr break-lock bzr+ssh://example.com/bzr/foo
5471
bzr break-lock --conf ~/.bazaar
5472
4684
"""
5473
5474
4685
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
]
5481
4686
5482
def run(self, location=None, config=False, force=False):
4687
def run(self, location=None, show=False):
5483
4688
if location is None:
5484
4689
location = u'.'
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
4690
control, relpath = bzrdir.BzrDir.open_containing(location)
4691
try:
4692
control.break_lock()
4693
except NotImplementedError:
4694
pass
5498
4695
5499
4696
5500
4697
class cmd_wait_until_signalled(Command):
5501
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4698
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
5502
4699
5503
4700
This just prints a line to signal when it is ready, then blocks on stdin.
5504
4701
"""
5512
4709
5513
4710
5514
4711
class cmd_serve(Command):
5515
__doc__ = """Run the bzr server."""
4712
"""Run the bzr server."""
5516
4713
5517
4714
aliases = ['server']
5518
4715
5519
4716
takes_options = [
5520
4717
Option('inet',
5521
4718
help='Serve on stdin/out for use from inetd or sshd.'),
5522
RegistryOption('protocol',
5523
help="Protocol to serve.",
4719
RegistryOption('protocol',
4720
help="Protocol to serve.",
5524
4721
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
5525
4722
value_switches=True),
5526
Option('listen',
5527
help='Listen for connections on nominated address.', type=str),
5528
4723
Option('port',
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.'),
4724
help='Listen for connections on nominated port of the form '
4725
'[hostname:]portnumber. Passing 0 as the port number will '
4726
'result in a dynamically allocated port. The default port '
4727
'depends on the protocol.',
4728
type=str),
4729
Option('directory',
4730
help='Serve contents of this directory.',
4731
type=unicode),
5535
4732
Option('allow-writes',
5536
4733
help='By default the server is a readonly server. Supplying '
5537
4734
'--allow-writes enables write access to the contents of '
5538
'the served directory and below. Note that ``bzr serve`` '
5539
'does not perform authentication, so unless some form of '
5540
'external authentication is arranged supplying this '
5541
'option leads to global uncontrolled write access to your '
5542
'file system.'
4735
'the served directory and below.'
5543
4736
),
5544
Option('client-timeout', type=float,
5545
help='Override the default idle client timeout (5min).'),
5546
4737
]
5547
4738
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
4739
def get_host_and_port(self, port):
4740
"""Return the host and port to run the smart server on.
4741
4742
If 'port' is None, None will be returned for the host and port.
4743
4744
If 'port' has a colon in it, the string before the colon will be
4745
interpreted as the host.
4746
4747
:param port: A string of the port to run the server on.
4748
:return: A tuple of (host, port), where 'host' is a host name or IP,
4749
and port is an integer TCP/IP port.
4750
"""
4751
host = None
4752
if port is not None:
4753
if ':' in port:
4754
host, port = port.split(':')
4755
port = int(port)
4756
return host, port
4757
4758
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4759
protocol=None):
4760
from bzrlib.transport import get_transport, transport_server_registry
5551
4761
if directory is None:
5552
4762
directory = os.getcwd()
5553
4763
if protocol is None:
5554
protocol = transport.transport_server_registry.get()
5555
url = transport.location_to_url(directory)
4764
protocol = transport_server_registry.get()
4765
host, port = self.get_host_and_port(port)
4766
url = urlutils.local_path_to_url(directory)
5556
4767
if not allow_writes:
5557
4768
url = 'readonly+' + url
5558
t = transport.get_transport_from_url(url)
5559
protocol(t, listen, port, inet, client_timeout)
4769
transport = get_transport(url)
4770
protocol(transport, host, port, inet)
5560
4771
5561
4772
5562
4773
class cmd_join(Command):
5563
__doc__ = """Combine a tree into its containing tree.
4774
"""Combine a tree into its containing tree.
5564
4775
5565
4776
This command requires the target tree to be in a rich-root format.
5566
4777
5568
4779
not part of it. (Such trees can be produced by "bzr split", but also by
5569
4780
running "bzr branch" with the target inside a tree.)
5570
4781
5571
The result is a combined tree, with the subtree no longer an independent
4782
The result is a combined tree, with the subtree no longer an independant
5572
4783
part. This is marked as a merge of the subtree into the containing tree,
5573
4784
and all history is preserved.
5574
4785
"""
5585
4796
containing_tree = WorkingTree.open_containing(parent_dir)[0]
5586
4797
repo = containing_tree.branch.repository
5587
4798
if not repo.supports_rich_root():
5588
raise errors.BzrCommandError(gettext(
4799
raise errors.BzrCommandError(
5589
4800
"Can't join trees because %s doesn't support rich root data.\n"
5590
"You can use bzr upgrade on the repository.")
4801
"You can use bzr upgrade on the repository."
5591
4802
% (repo,))
5592
4803
if reference:
5593
4804
try:
5595
4806
except errors.BadReferenceTarget, e:
5596
4807
# XXX: Would be better to just raise a nicely printable
5597
4808
# exception from the real origin. Also below. mbp 20070306
5598
raise errors.BzrCommandError(
5599
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4809
raise errors.BzrCommandError("Cannot join %s. %s" %
4810
(tree, e.reason))
5600
4811
else:
5601
4812
try:
5602
4813
containing_tree.subsume(sub_tree)
5603
4814
except errors.BadSubsumeSource, e:
5604
raise errors.BzrCommandError(
5605
gettext("Cannot join {0}. {1}").format(tree, e.reason))
4815
raise errors.BzrCommandError("Cannot join %s. %s" %
4816
(tree, e.reason))
5606
4817
5607
4818
5608
4819
class cmd_split(Command):
5609
__doc__ = """Split a subdirectory of a tree into a separate tree.
4820
"""Split a subdirectory of a tree into a separate tree.
5610
4821
5611
4822
This command will produce a target tree in a format that supports
5612
4823
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5632
4843
5633
4844
5634
4845
class cmd_merge_directive(Command):
5635
__doc__ = """Generate a merge directive for auto-merge tools.
4846
"""Generate a merge directive for auto-merge tools.
5636
4847
5637
4848
A directive requests a merge to be performed, and also provides all the
5638
4849
information necessary to do so. This means it must either include a
5655
4866
_see_also = ['send']
5656
4867
5657
4868
takes_options = [
5658
'directory',
5659
4869
RegistryOption.from_kwargs('patch-type',
5660
4870
'The type of patch to include in the directive.',
5661
4871
title='Patch type',
5674
4884
encoding_type = 'exact'
5675
4885
5676
4886
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5677
sign=False, revision=None, mail_to=None, message=None,
5678
directory=u'.'):
4887
sign=False, revision=None, mail_to=None, message=None):
5679
4888
from bzrlib.revision import ensure_null, NULL_REVISION
5680
4889
include_patch, include_bundle = {
5681
4890
'plain': (False, False),
5682
4891
'diff': (True, False),
5683
4892
'bundle': (True, True),
5684
4893
}[patch_type]
5685
branch = Branch.open(directory)
4894
branch = Branch.open('.')
5686
4895
stored_submit_branch = branch.get_submit_branch()
5687
4896
if submit_branch is None:
5688
4897
submit_branch = stored_submit_branch
5692
4901
if submit_branch is None:
5693
4902
submit_branch = branch.get_parent()
5694
4903
if submit_branch is None:
5695
raise errors.BzrCommandError(gettext('No submit branch specified or known'))
4904
raise errors.BzrCommandError('No submit branch specified or known')
5696
4905
5697
4906
stored_public_branch = branch.get_public_branch()
5698
4907
if public_branch is None:
5699
4908
public_branch = stored_public_branch
5700
4909
elif stored_public_branch is None:
5701
# FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5702
4910
branch.set_public_branch(public_branch)
5703
4911
if not include_bundle and public_branch is None:
5704
raise errors.BzrCommandError(gettext('No public branch specified or'
5705
' known'))
4912
raise errors.BzrCommandError('No public branch specified or'
4913
' known')
5706
4914
base_revision_id = None
5707
4915
if revision is not None:
5708
4916
if len(revision) > 2:
5709
raise errors.BzrCommandError(gettext('bzr merge-directive takes '
5710
'at most two one revision identifiers'))
4917
raise errors.BzrCommandError('bzr merge-directive takes '
4918
'at most two one revision identifiers')
5711
4919
revision_id = revision[-1].as_revision_id(branch)
5712
4920
if len(revision) == 2:
5713
4921
base_revision_id = revision[0].as_revision_id(branch)
5715
4923
revision_id = branch.last_revision()
5716
4924
revision_id = ensure_null(revision_id)
5717
4925
if revision_id == NULL_REVISION:
5718
raise errors.BzrCommandError(gettext('No revisions to bundle.'))
4926
raise errors.BzrCommandError('No revisions to bundle.')
5719
4927
directive = merge_directive.MergeDirective2.from_objects(
5720
4928
branch.repository, revision_id, time.time(),
5721
4929
osutils.local_time_offset(), submit_branch,
5729
4937
self.outf.writelines(directive.to_lines())
5730
4938
else:
5731
4939
message = directive.to_email(mail_to, branch, sign)
5732
s = SMTPConnection(branch.get_config_stack())
4940
s = SMTPConnection(branch.get_config())
5733
4941
s.send_email(message)
5734
4942
5735
4943
5736
4944
class cmd_send(Command):
5737
__doc__ = """Mail or create a merge-directive for submitting changes.
4945
"""Mail or create a merge-directive for submitting changes.
5738
4946
5739
4947
A merge directive provides many things needed for requesting merges:
5740
4948
5746
4954
directly from the merge directive, without retrieving data from a
5747
4955
branch.
5748
4956
5749
`bzr send` creates a compact data set that, when applied using bzr
5750
merge, has the same effect as merging from the source branch.
5751
5752
By default the merge directive is self-contained and can be applied to any
5753
branch containing submit_branch in its ancestory without needing access to
5754
the source branch.
5755
5756
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5757
revisions, but only a structured request to merge from the
5758
public_location. In that case the public_branch is needed and it must be
5759
up-to-date and accessible to the recipient. The public_branch is always
5760
included if known, so that people can check it later.
5761
5762
The submit branch defaults to the parent of the source branch, but can be
5763
overridden. Both submit branch and public branch will be remembered in
5764
branch.conf the first time they are used for a particular branch. The
5765
source branch defaults to that containing the working directory, but can
5766
be changed using --from.
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
5774
In order to calculate those changes, bzr must analyse the submit branch.
5775
Therefore it is most efficient for the submit branch to be a local mirror.
5776
If a public location is known for the submit_branch, that location is used
5777
in the merge directive.
5778
5779
The default behaviour is to send the merge directive by mail, unless -o is
5780
given, in which case it is sent to a file.
4957
If --no-bundle is specified, then public_branch is needed (and must be
4958
up-to-date), so that the receiver can perform the merge using the
4959
public_branch. The public_branch is always included if known, so that
4960
people can check it later.
4961
4962
The submit branch defaults to the parent, but can be overridden. Both
4963
submit branch and public branch will be remembered if supplied.
4964
4965
If a public_branch is known for the submit_branch, that public submit
4966
branch is used in the merge instructions. This means that a local mirror
4967
can be used as your actual submit branch, once you have set public_branch
4968
for that mirror.
5781
4969
5782
4970
Mail is sent using your preferred mail program. This should be transparent
5783
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
4971
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5784
4972
If the preferred client can't be found (or used), your editor will be used.
5785
4973
5786
4974
To use a specific mail program, set the mail_client configuration option.
5787
4975
(For Thunderbird 1.5, this works around some bugs.) Supported values for
5788
specific clients are "claws", "evolution", "kmail", "mail.app" (MacOS X's
5789
Mail.app), "mutt", and "thunderbird"; generic options are "default",
5790
"editor", "emacsclient", "mapi", and "xdg-email". Plugins may also add
5791
supported clients.
4976
specific clients are "claws", "evolution", "kmail", "mutt", and
4977
"thunderbird"; generic options are "default", "editor", "emacsclient",
4978
"mapi", and "xdg-email". Plugins may also add supported clients.
5792
4979
5793
4980
If mail is being sent, a to address is required. This can be supplied
5794
4981
either on the commandline, by setting the submit_to configuration
5803
4990
5804
4991
The merge directives created by bzr send may be applied using bzr merge or
5805
4992
bzr pull by specifying a file containing a merge directive as the location.
5806
5807
bzr send makes extensive use of public locations to map local locations into
5808
URLs that can be used by other people. See `bzr help configuration` to
5809
set them, and use `bzr info` to display them.
5810
4993
"""
5811
4994
5812
4995
encoding_type = 'exact'
5828
5011
short_name='f',
5829
5012
type=unicode),
5830
5013
Option('output', short_name='o',
5831
help='Write merge directive to this file or directory; '
5014
help='Write merge directive to this file; '
5832
5015
'use - for stdout.',
5833
5016
type=unicode),
5834
5017
Option('strict',
5845
5028
]
5846
5029
5847
5030
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5848
no_patch=False, revision=None, remember=None, output=None,
5031
no_patch=False, revision=None, remember=False, output=None,
5849
5032
format=None, mail_to=None, message=None, body=None,
5850
5033
strict=None, **kwargs):
5851
5034
from bzrlib.send import send
5857
5040
5858
5041
5859
5042
class cmd_bundle_revisions(cmd_send):
5860
__doc__ = """Create a merge-directive for submitting changes.
5043
"""Create a merge-directive for submitting changes.
5861
5044
5862
5045
A merge directive provides many things needed for requesting merges:
5863
5046
5930
5113
5931
5114
5932
5115
class cmd_tag(Command):
5933
__doc__ = """Create, remove or modify a tag naming a revision.
5116
"""Create, remove or modify a tag naming a revision.
5934
5117
5935
5118
Tags give human-meaningful names to revisions. Commands that take a -r
5936
5119
(--revision) option can be given -rtag:X, where X is any previously
5944
5127
5945
5128
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5946
5129
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.
5952
5130
"""
5953
5131
5954
5132
_see_also = ['commit', 'tags']
5955
takes_args = ['tag_name?']
5133
takes_args = ['tag_name']
5956
5134
takes_options = [
5957
5135
Option('delete',
5958
5136
help='Delete this tag rather than placing it.',
5959
5137
),
5960
custom_help('directory',
5961
help='Branch in which to place the tag.'),
5138
Option('directory',
5139
help='Branch in which to place the tag.',
5140
short_name='d',
5141
type=unicode,
5142
),
5962
5143
Option('force',
5963
5144
help='Replace existing tags.',
5964
5145
),
5965
5146
'revision',
5966
5147
]
5967
5148
5968
def run(self, tag_name=None,
5149
def run(self, tag_name,
5969
5150
delete=None,
5970
5151
directory='.',
5971
5152
force=None,
5972
5153
revision=None,
5973
5154
):
5974
5155
branch, relpath = Branch.open_containing(directory)
5975
self.add_cleanup(branch.lock_write().unlock)
5976
if delete:
5977
if tag_name is None:
5978
raise errors.BzrCommandError(gettext("No tag specified to delete."))
5979
branch.tags.delete_tag(tag_name)
5980
note(gettext('Deleted tag %s.') % tag_name)
5981
else:
5982
if revision:
5983
if len(revision) != 1:
5984
raise errors.BzrCommandError(gettext(
5985
"Tags can only be placed on a single revision, "
5986
"not on a range"))
5987
revision_id = revision[0].as_revision_id(branch)
5988
else:
5989
revision_id = branch.last_revision()
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):
6000
raise errors.TagAlreadyExists(tag_name)
6001
if existing_target == revision_id:
6002
note(gettext('Tag %s already exists for that revision.') % tag_name)
6003
else:
5156
branch.lock_write()
5157
try:
5158
if delete:
5159
branch.tags.delete_tag(tag_name)
5160
self.outf.write('Deleted tag %s.\n' % tag_name)
5161
else:
5162
if revision:
5163
if len(revision) != 1:
5164
raise errors.BzrCommandError(
5165
"Tags can only be placed on a single revision, "
5166
"not on a range")
5167
revision_id = revision[0].as_revision_id(branch)
5168
else:
5169
revision_id = branch.last_revision()
5170
if (not force) and branch.tags.has_tag(tag_name):
5171
raise errors.TagAlreadyExists(tag_name)
6004
5172
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)
5173
self.outf.write('Created tag %s.\n' % tag_name)
5174
finally:
5175
branch.unlock()
6009
5176
6010
5177
6011
5178
class cmd_tags(Command):
6012
__doc__ = """List tags.
5179
"""List tags.
6013
5180
6014
5181
This command shows a table of tag names and the revisions they reference.
6015
5182
"""
6016
5183
6017
5184
_see_also = ['tag']
6018
5185
takes_options = [
6019
custom_help('directory',
6020
help='Branch whose tags should be displayed.'),
6021
RegistryOption('sort',
5186
Option('directory',
5187
help='Branch whose tags should be displayed.',
5188
short_name='d',
5189
type=unicode,
5190
),
5191
RegistryOption.from_kwargs('sort',
6022
5192
'Sort tags by different criteria.', title='Sorting',
6023
lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5193
alpha='Sort tags lexicographically (default).',
5194
time='Sort tags chronologically.',
6024
5195
),
6025
5196
'show-ids',
6026
5197
'revision',
6027
5198
]
6028
5199
6029
5200
@display_command
6030
def run(self, directory='.', sort=None, show_ids=False, revision=None):
6031
from bzrlib.tag import tag_sort_methods
5201
def run(self,
5202
directory='.',
5203
sort='alpha',
5204
show_ids=False,
5205
revision=None,
5206
):
6032
5207
branch, relpath = Branch.open_containing(directory)
6033
5208
6034
5209
tags = branch.tags.get_tag_dict().items()
6035
5210
if not tags:
6036
5211
return
6037
5212
6038
self.add_cleanup(branch.lock_read().unlock)
6039
if revision:
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)
6045
if not show_ids:
6046
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
6047
for index, (tag, revid) in enumerate(tags):
6048
try:
6049
revno = branch.revision_id_to_dotted_revno(revid)
6050
if isinstance(revno, tuple):
6051
revno = '.'.join(map(str, revno))
6052
except (errors.NoSuchRevision,
6053
errors.GhostRevisionsHaveNoRevno,
6054
errors.UnsupportedOperation):
6055
# Bad tag data/merges can lead to tagged revisions
6056
# which are not in this branch. Fail gracefully ...
6057
revno = '?'
6058
tags[index] = (tag, revno)
6059
self.cleanup_now()
5213
branch.lock_read()
5214
try:
5215
if revision:
5216
graph = branch.repository.get_graph()
5217
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5218
revid1, revid2 = rev1.rev_id, rev2.rev_id
5219
# only show revisions between revid1 and revid2 (inclusive)
5220
tags = [(tag, revid) for tag, revid in tags if
5221
graph.is_between(revid, revid1, revid2)]
5222
if sort == 'alpha':
5223
tags.sort()
5224
elif sort == 'time':
5225
timestamps = {}
5226
for tag, revid in tags:
5227
try:
5228
revobj = branch.repository.get_revision(revid)
5229
except errors.NoSuchRevision:
5230
timestamp = sys.maxint # place them at the end
5231
else:
5232
timestamp = revobj.timestamp
5233
timestamps[revid] = timestamp
5234
tags.sort(key=lambda x: timestamps[x[1]])
5235
if not show_ids:
5236
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5237
for index, (tag, revid) in enumerate(tags):
5238
try:
5239
revno = branch.revision_id_to_dotted_revno(revid)
5240
if isinstance(revno, tuple):
5241
revno = '.'.join(map(str, revno))
5242
except errors.NoSuchRevision:
5243
# Bad tag data/merges can lead to tagged revisions
5244
# which are not in this branch. Fail gracefully ...
5245
revno = '?'
5246
tags[index] = (tag, revno)
5247
finally:
5248
branch.unlock()
6060
5249
for tag, revspec in tags:
6061
5250
self.outf.write('%-20s %s\n' % (tag, revspec))
6062
5251
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
6089
5252
6090
5253
class cmd_reconfigure(Command):
6091
__doc__ = """Reconfigure the type of a bzr directory.
5254
"""Reconfigure the type of a bzr directory.
6092
5255
6093
5256
A target configuration must be specified.
6094
5257
6105
5268
takes_args = ['location?']
6106
5269
takes_options = [
6107
5270
RegistryOption.from_kwargs(
6108
'tree_type',
6109
title='Tree type',
6110
help='The relation between branch and tree.',
5271
'target_type',
5272
title='Target type',
5273
help='The type to reconfigure the directory to.',
6111
5274
value_switches=True, enum_switch=False,
6112
5275
branch='Reconfigure to be an unbound branch with no working tree.',
6113
5276
tree='Reconfigure to be an unbound branch with a working tree.',
6114
5277
checkout='Reconfigure to be a bound branch with a working tree.',
6115
5278
lightweight_checkout='Reconfigure to be a lightweight'
6116
5279
' 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,
6123
5280
standalone='Reconfigure to be a standalone branch '
6124
5281
'(i.e. stop using shared repository).',
6125
5282
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,
6132
5283
with_trees='Reconfigure repository to create '
6133
5284
'working trees on branches by default.',
6134
5285
with_no_trees='Reconfigure repository to not create '
6148
5299
),
6149
5300
]
6150
5301
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)
5302
def run(self, location=None, target_type=None, bind_to=None, force=False,
5303
stacked_on=None,
5304
unstacked=None):
5305
directory = bzrdir.BzrDir.open(location)
6155
5306
if stacked_on and unstacked:
6156
raise errors.BzrCommandError(gettext("Can't use both --stacked-on and --unstacked"))
5307
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
6157
5308
elif stacked_on is not None:
6158
5309
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
6159
5310
elif unstacked:
6161
5312
# At the moment you can use --stacked-on and a different
6162
5313
# reconfiguration shape at the same time; there seems no good reason
6163
5314
# to ban it.
6164
if (tree_type is None and
6165
repository_type is None and
6166
repository_trees is None):
5315
if target_type is None:
6167
5316
if stacked_on or unstacked:
6168
5317
return
6169
5318
else:
6170
raise errors.BzrCommandError(gettext('No target configuration '
6171
'specified'))
6172
reconfiguration = None
6173
if tree_type == 'branch':
5319
raise errors.BzrCommandError('No target configuration '
5320
'specified')
5321
elif target_type == 'branch':
6174
5322
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
6175
elif tree_type == 'tree':
5323
elif target_type == 'tree':
6176
5324
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
6177
elif tree_type == 'checkout':
5325
elif target_type == 'checkout':
6178
5326
reconfiguration = reconfigure.Reconfigure.to_checkout(
6179
5327
directory, bind_to)
6180
elif tree_type == 'lightweight-checkout':
5328
elif target_type == 'lightweight-checkout':
6181
5329
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
6182
5330
directory, bind_to)
6183
if reconfiguration:
6184
reconfiguration.apply(force)
6185
reconfiguration = None
6186
if repository_type == 'use-shared':
5331
elif target_type == 'use-shared':
6187
5332
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
6188
elif repository_type == 'standalone':
5333
elif target_type == 'standalone':
6189
5334
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
6190
if reconfiguration:
6191
reconfiguration.apply(force)
6192
reconfiguration = None
6193
if repository_trees == 'with-trees':
5335
elif target_type == 'with-trees':
6194
5336
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
6195
5337
directory, True)
6196
elif repository_trees == 'with-no-trees':
5338
elif target_type == 'with-no-trees':
6197
5339
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
6198
5340
directory, False)
6199
if reconfiguration:
6200
reconfiguration.apply(force)
6201
reconfiguration = None
5341
reconfiguration.apply(force)
6202
5342
6203
5343
6204
5344
class cmd_switch(Command):
6205
__doc__ = """Set the branch of a checkout and update.
5345
"""Set the branch of a checkout and update.
6206
5346
6207
5347
For lightweight checkouts, this changes the branch being referenced.
6208
5348
For heavyweight checkouts, this checks that there are no local commits
6220
5360
/path/to/newbranch.
6221
5361
6222
5362
Bound branches use the nickname of its master branch unless it is set
6223
locally, in which case switching will update the local nickname to be
5363
locally, in which case switching will update the the local nickname to be
6224
5364
that of the master.
6225
5365
"""
6226
5366
6227
takes_args = ['to_location?']
6228
takes_options = ['directory',
6229
Option('force',
5367
takes_args = ['to_location']
5368
takes_options = [Option('force',
6230
5369
help='Switch even if local commits will be lost.'),
6231
'revision',
6232
5370
Option('create-branch', short_name='b',
6233
5371
help='Create the target branch from this one before'
6234
5372
' switching to it.'),
6235
Option('store',
6236
help='Store and restore uncommitted changes in the'
6237
' branch.'),
6238
]
5373
]
6239
5374
6240
def run(self, to_location=None, force=False, create_branch=False,
6241
revision=None, directory=u'.', store=False):
5375
def run(self, to_location, force=False, create_branch=False):
6242
5376
from bzrlib import switch
6243
tree_location = directory
6244
revision = _get_one_revision('switch', revision)
6245
possible_transports = []
6246
control_dir = controldir.ControlDir.open_containing(tree_location,
6247
possible_transports=possible_transports)[0]
6248
if to_location is None:
6249
if revision is None:
6250
raise errors.BzrCommandError(gettext('You must supply either a'
6251
' revision or a location'))
6252
to_location = tree_location
5377
tree_location = '.'
5378
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
6253
5379
try:
6254
branch = control_dir.open_branch(
6255
possible_transports=possible_transports)
5380
branch = control_dir.open_branch()
6256
5381
had_explicit_nick = branch.get_config().has_explicit_nickname()
6257
5382
except errors.NotBranchError:
6258
5383
branch = None
6259
5384
had_explicit_nick = False
6260
5385
if create_branch:
6261
5386
if branch is None:
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)
5387
raise errors.BzrCommandError('cannot create branch without'
5388
' source branch')
5389
if '/' not in to_location and '\\' not in to_location:
5390
# This path is meant to be relative to the existing branch
5391
this_url = self._get_branch_location(control_dir)
5392
to_location = urlutils.join(this_url, '..', to_location)
6266
5393
to_branch = branch.bzrdir.sprout(to_location,
6267
possible_transports=possible_transports,
6268
source_branch=branch).open_branch()
5394
possible_transports=[branch.bzrdir.root_transport],
5395
source_branch=branch).open_branch()
5396
# try:
5397
# from_branch = control_dir.open_branch()
5398
# except errors.NotBranchError:
5399
# raise BzrCommandError('Cannot create a branch from this'
5400
# ' location when we cannot open this branch')
5401
# from_branch.bzrdir.sprout(
5402
pass
6269
5403
else:
6270
5404
try:
6271
to_branch = Branch.open(to_location,
6272
possible_transports=possible_transports)
5405
to_branch = Branch.open(to_location)
6273
5406
except errors.NotBranchError:
6274
to_branch = open_sibling_branch(control_dir, to_location,
6275
possible_transports=possible_transports)
6276
if revision is not None:
6277
revision = revision.as_revision_id(to_branch)
6278
switch.switch(control_dir, to_branch, force, revision_id=revision,
6279
store_uncommitted=store)
5407
this_url = self._get_branch_location(control_dir)
5408
to_branch = Branch.open(
5409
urlutils.join(this_url, '..', to_location))
5410
switch.switch(control_dir, to_branch, force)
6280
5411
if had_explicit_nick:
6281
5412
branch = control_dir.open_branch() #get the new branch!
6282
5413
branch.nick = to_branch.nick
6283
note(gettext('Switched to branch: %s'),
5414
note('Switched to branch: %s',
6284
5415
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
6285
5416
5417
def _get_branch_location(self, control_dir):
5418
"""Return location of branch for this control dir."""
5419
try:
5420
this_branch = control_dir.open_branch()
5421
# This may be a heavy checkout, where we want the master branch
5422
master_location = this_branch.get_bound_location()
5423
if master_location is not None:
5424
return master_location
5425
# If not, use a local sibling
5426
return this_branch.base
5427
except errors.NotBranchError:
5428
format = control_dir.find_branch_format()
5429
if getattr(format, 'get_reference', None) is not None:
5430
return format.get_reference(control_dir)
5431
else:
5432
return control_dir.root_transport.base
6286
5433
6287
5434
6288
5435
class cmd_view(Command):
6289
__doc__ = """Manage filtered views.
5436
"""Manage filtered views.
6290
5437
6291
5438
Views provide a mask over the tree so that users can focus on
6292
5439
a subset of a tree when doing their work. After creating a view,
6372
5519
name=None,
6373
5520
switch=None,
6374
5521
):
6375
tree, file_list = WorkingTree.open_containing_paths(file_list,
6376
apply_view=False)
5522
tree, file_list = tree_files(file_list, apply_view=False)
6377
5523
current_view, view_dict = tree.views.get_view_info()
6378
5524
if name is None:
6379
5525
name = current_view
6380
5526
if delete:
6381
5527
if file_list:
6382
raise errors.BzrCommandError(gettext(
6383
"Both --delete and a file list specified"))
5528
raise errors.BzrCommandError(
5529
"Both --delete and a file list specified")
6384
5530
elif switch:
6385
raise errors.BzrCommandError(gettext(
6386
"Both --delete and --switch specified"))
5531
raise errors.BzrCommandError(
5532
"Both --delete and --switch specified")
6387
5533
elif all:
6388
5534
tree.views.set_view_info(None, {})
6389
self.outf.write(gettext("Deleted all views.\n"))
5535
self.outf.write("Deleted all views.\n")
6390
5536
elif name is None:
6391
raise errors.BzrCommandError(gettext("No current view to delete"))
5537
raise errors.BzrCommandError("No current view to delete")
6392
5538
else:
6393
5539
tree.views.delete_view(name)
6394
self.outf.write(gettext("Deleted '%s' view.\n") % name)
5540
self.outf.write("Deleted '%s' view.\n" % name)
6395
5541
elif switch:
6396
5542
if file_list:
6397
raise errors.BzrCommandError(gettext(
6398
"Both --switch and a file list specified"))
5543
raise errors.BzrCommandError(
5544
"Both --switch and a file list specified")
6399
5545
elif all:
6400
raise errors.BzrCommandError(gettext(
6401
"Both --switch and --all specified"))
5546
raise errors.BzrCommandError(
5547
"Both --switch and --all specified")
6402
5548
elif switch == 'off':
6403
5549
if current_view is None:
6404
raise errors.BzrCommandError(gettext("No current view to disable"))
5550
raise errors.BzrCommandError("No current view to disable")
6405
5551
tree.views.set_view_info(None, view_dict)
6406
self.outf.write(gettext("Disabled '%s' view.\n") % (current_view))
5552
self.outf.write("Disabled '%s' view.\n" % (current_view))
6407
5553
else:
6408
5554
tree.views.set_view_info(switch, view_dict)
6409
5555
view_str = views.view_display_str(tree.views.lookup_view())
6410
self.outf.write(gettext("Using '{0}' view: {1}\n").format(switch, view_str))
5556
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
6411
5557
elif all:
6412
5558
if view_dict:
6413
self.outf.write(gettext('Views defined:\n'))
5559
self.outf.write('Views defined:\n')
6414
5560
for view in sorted(view_dict):
6415
5561
if view == current_view:
6416
5562
active = "=>"
6419
5565
view_str = views.view_display_str(view_dict[view])
6420
5566
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
6421
5567
else:
6422
self.outf.write(gettext('No views defined.\n'))
5568
self.outf.write('No views defined.\n')
6423
5569
elif file_list:
6424
5570
if name is None:
6425
5571
# No name given and no current view set
6426
5572
name = 'my'
6427
5573
elif name == 'off':
6428
raise errors.BzrCommandError(gettext(
6429
"Cannot change the 'off' pseudo view"))
5574
raise errors.BzrCommandError(
5575
"Cannot change the 'off' pseudo view")
6430
5576
tree.views.set_view(name, sorted(file_list))
6431
5577
view_str = views.view_display_str(tree.views.lookup_view())
6432
self.outf.write(gettext("Using '{0}' view: {1}\n").format(name, view_str))
5578
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
6433
5579
else:
6434
5580
# list the files
6435
5581
if name is None:
6436
5582
# No name given and no current view set
6437
self.outf.write(gettext('No current view.\n'))
5583
self.outf.write('No current view.\n')
6438
5584
else:
6439
5585
view_str = views.view_display_str(tree.views.lookup_view(name))
6440
self.outf.write(gettext("'{0}' view is: {1}\n").format(name, view_str))
5586
self.outf.write("'%s' view is: %s\n" % (name, view_str))
6441
5587
6442
5588
6443
5589
class cmd_hooks(Command):
6444
__doc__ = """Show hooks."""
5590
"""Show hooks."""
6445
5591
6446
5592
hidden = True
6447
5593
6457
5603
self.outf.write(" %s\n" %
6458
5604
(some_hooks.get_hook_name(hook),))
6459
5605
else:
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)
5606
self.outf.write(" <no hooks installed>\n")
6496
5607
6497
5608
6498
5609
class cmd_shelve(Command):
6499
__doc__ = """Temporarily set aside some changes from the current tree.
5610
"""Temporarily set aside some changes from the current tree.
6500
5611
6501
5612
Shelve allows you to temporarily put changes you've made "on the shelf",
6502
5613
ie. out of the way, until a later time when you can bring them back from
6518
5629
6519
5630
You can put multiple items on the shelf, and by default, 'unshelve' will
6520
5631
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
6533
5632
"""
6534
5633
6535
5634
takes_args = ['file*']
6536
5635
6537
5636
takes_options = [
6538
'directory',
6539
5637
'revision',
6540
5638
Option('all', help='Shelve all changes.'),
6541
5639
'message',
6547
5645
Option('destroy',
6548
5646
help='Destroy removed changes instead of shelving them.'),
6549
5647
]
6550
_see_also = ['unshelve', 'configuration']
5648
_see_also = ['unshelve']
6551
5649
6552
5650
def run(self, revision=None, all=False, file_list=None, message=None,
6553
writer=None, list=False, destroy=False, directory=None):
5651
writer=None, list=False, destroy=False):
6554
5652
if list:
6555
return self.run_for_list(directory=directory)
5653
return self.run_for_list()
6556
5654
from bzrlib.shelf_ui import Shelver
6557
5655
if writer is None:
6558
5656
writer = bzrlib.option.diff_writer_registry.get()
6559
5657
try:
6560
5658
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6561
file_list, message, destroy=destroy, directory=directory)
5659
file_list, message, destroy=destroy)
6562
5660
try:
6563
5661
shelver.run()
6564
5662
finally:
6565
shelver.finalize()
5663
shelver.work_tree.unlock()
6566
5664
except errors.UserAbort:
6567
5665
return 0
6568
5666
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)
6574
manager = tree.get_shelf_manager()
6575
shelves = manager.active_shelves()
6576
if len(shelves) == 0:
6577
note(gettext('No shelved changes.'))
6578
return 0
6579
for shelf_id in reversed(shelves):
6580
message = manager.get_metadata(shelf_id).get('message')
6581
if message is None:
6582
message = '<no message>'
6583
self.outf.write('%3d: %s\n' % (shelf_id, message))
6584
return 1
5667
def run_for_list(self):
5668
tree = WorkingTree.open_containing('.')[0]
5669
tree.lock_read()
5670
try:
5671
manager = tree.get_shelf_manager()
5672
shelves = manager.active_shelves()
5673
if len(shelves) == 0:
5674
note('No shelved changes.')
5675
return 0
5676
for shelf_id in reversed(shelves):
5677
message = manager.get_metadata(shelf_id).get('message')
5678
if message is None:
5679
message = '<no message>'
5680
self.outf.write('%3d: %s\n' % (shelf_id, message))
5681
return 1
5682
finally:
5683
tree.unlock()
6585
5684
6586
5685
6587
5686
class cmd_unshelve(Command):
6588
__doc__ = """Restore shelved changes.
5687
"""Restore shelved changes.
6589
5688
6590
5689
By default, the most recently shelved changes are restored. However if you
6591
5690
specify a shelf by id those changes will be restored instead. This works
6594
5693
6595
5694
takes_args = ['shelf_id?']
6596
5695
takes_options = [
6597
'directory',
6598
5696
RegistryOption.from_kwargs(
6599
5697
'action', help="The action to perform.",
6600
5698
enum_switch=False, value_switches=True,
6601
5699
apply="Apply changes and remove from the shelf.",
6602
5700
dry_run="Show changes, but do not apply or remove them.",
6603
preview="Instead of unshelving the changes, show the diff that "
6604
"would result from unshelving.",
6605
delete_only="Delete changes without applying them.",
6606
keep="Apply changes but don't delete them.",
5701
delete_only="Delete changes without applying them."
6607
5702
)
6608
5703
]
6609
5704
_see_also = ['shelve']
6610
5705
6611
def run(self, shelf_id=None, action='apply', directory=u'.'):
5706
def run(self, shelf_id=None, action='apply'):
6612
5707
from bzrlib.shelf_ui import Unshelver
6613
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5708
unshelver = Unshelver.from_args(shelf_id, action)
6614
5709
try:
6615
5710
unshelver.run()
6616
5711
finally:
6618
5713
6619
5714
6620
5715
class cmd_clean_tree(Command):
6621
__doc__ = """Remove unwanted files from working tree.
5716
"""Remove unwanted files from working tree.
6622
5717
6623
5718
By default, only unknown files, not ignored files, are deleted. Versioned
6624
5719
files are never deleted.
6632
5727
6633
5728
To check what clean-tree will do, use --dry-run.
6634
5729
"""
6635
takes_options = ['directory',
6636
Option('ignored', help='Delete all ignored files.'),
6637
Option('detritus', help='Delete conflict files, merge and revert'
5730
takes_options = [Option('ignored', help='Delete all ignored files.'),
5731
Option('detritus', help='Delete conflict files, merge'
6638
5732
' backups, and failed selftest dirs.'),
6639
5733
Option('unknown',
6640
5734
help='Delete files unknown to bzr (default).'),
6642
5736
' deleting them.'),
6643
5737
Option('force', help='Do not prompt before deleting.')]
6644
5738
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6645
force=False, directory=u'.'):
5739
force=False):
6646
5740
from bzrlib.clean_tree import clean_tree
6647
5741
if not (unknown or ignored or detritus):
6648
5742
unknown = True
6649
5743
if dry_run:
6650
5744
force = True
6651
clean_tree(directory, unknown=unknown, ignored=ignored,
6652
detritus=detritus, dry_run=dry_run, no_prompt=force)
5745
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5746
dry_run=dry_run, no_prompt=force)
6653
5747
6654
5748
6655
5749
class cmd_reference(Command):
6656
__doc__ = """list, view and set branch locations for nested trees.
5750
"""list, view and set branch locations for nested trees.
6657
5751
6658
5752
If no arguments are provided, lists the branch locations for nested trees.
6659
5753
If one argument is provided, display the branch location for that tree.
6669
5763
if path is not None:
6670
5764
branchdir = path
6671
5765
tree, branch, relpath =(
6672
controldir.ControlDir.open_containing_tree_or_branch(branchdir))
5766
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
6673
5767
if path is not None:
6674
5768
path = relpath
6675
5769
if tree is None:
6699
5793
self.outf.write('%s %s\n' % (path, location))
6700
5794
6701
5795
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)
5796
# these get imported and then picked up by the scan for cmd_*
5797
# TODO: Some more consistent way to split command definitions across files;
5798
# we do need to load at least some information about them to know of
5799
# aliases. ideally we would avoid loading the implementation until the
5800
# details were needed.
5801
from bzrlib.cmd_version_info import cmd_version_info
5802
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5803
from bzrlib.bundle.commands import (
5804
cmd_bundle_info,
5805
)
5806
from bzrlib.foreign import cmd_dpush
5807
from bzrlib.sign_my_commits import cmd_sign_my_commits
5808
from bzrlib.weave_commands import cmd_versionedfile_list, \
5809
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1