« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1861.2.9
- compare with another revision
- download diff
- download tarball
- view history from revision 1861.2.9
- Committer: Alexander Belchenko
- Date: 2006-07-30 16:43:12 UTC
- mto: (1711.2.111 jam-integration)
- mto: This revision was merged to the branch mainline in revision 1906.
- Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename gpl.txt => COPYING.txt
- files added:
- NEWS.developers
- bzrlib/bundle/old
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/util/configobj/docs
- bzrlib/util/urlgrabber
- files removed:
- bzrlib/_annotator_py.py
- bzrlib/benchmarks/tree_creator
- bzrlib/filters
- bzrlib/help_topics
- bzrlib/help_topics/en
- bzrlib/plugins/netrc_credential_store
- bzrlib/plugins/netrc_credential_store/tests
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/tests/commands
- bzrlib/tests/ftp_server
- bzrlib/tests/per_interbranch
- bzrlib/tests/per_inventory
- bzrlib/tests/per_lock
- bzrlib/tests/per_repository_chk
- bzrlib/tests/per_repository_reference
- bzrlib/tests/ssl_certs
- bzrlib/transport/ftp
- bzrlib/util/tests
- bzrlib/version_info_formats
- doc/developers
- doc/en
- doc/en/admin-guide
- doc/en/developer-guide
- doc/en/mini-tutorial
- doc/en/quick-reference
- doc/en/release-notes
- doc/en/tutorials
- doc/en/upgrade-guide
- doc/en/user-guide
- doc/en/user-guide/images
- doc/en/user-reference
- doc/es
- doc/es/developer-guide
- doc/es/mini-tutorial
- doc/es/quick-reference
- doc/es/release-notes
- doc/es/user-guide
- doc/es/user-reference
- doc/ru
- doc/ru/mini-tutorial
- doc/ru/quick-reference
- doc/ru/tutorials
- doc/ru/user-guide
- doc/ru/user-guide/images
- man1
- tools/packaging
- tools/win32/buildout-templates
- tools/win32/buildout-templates/bin
- files renamed:
- doc/en/developer-guide/HACKING.txt => HACKING
- bzrlib/deprecated_graph.py => bzrlib/graph.py
- bzrlib/_patiencediff_py.py => bzrlib/patiencediff.py
- bzrlib/tests/http_utils.py => bzrlib/tests/HTTPTestUtil.py
- bzrlib/tests/blackbox/test_send.py => bzrlib/tests/blackbox/test_bundle.py
- bzrlib/tests/per_branch/ => bzrlib/tests/branch_implementations/
- bzrlib/tests/per_bzrdir/ => bzrlib/tests/bzrdir_implementations/
- bzrlib/tests/per_interrepository/ => bzrlib/tests/interrepository_implementations/
- bzrlib/tests/per_intertree/ => bzrlib/tests/intertree_implementations/
- bzrlib/tests/per_repository/ => bzrlib/tests/repository_implementations/
- bzrlib/tests/test_commands.py => bzrlib/tests/test_command.py
- bzrlib/tests/test_deprecated_graph.py => bzrlib/tests/test_graph.py
- bzrlib/tests/test_revisionspec.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/tests/per_repository/test_revision.py => bzrlib/tests/test_revprops.py
- bzrlib/tests/per_transport.py => bzrlib/tests/test_transport_implementations.py
- bzrlib/tests/per_tree/ => bzrlib/tests/tree_implementations/
- bzrlib/tests/per_workingtree/ => bzrlib/tests/workingtree_implementations/
- bzrlib/transport/ftp/__init__.py => bzrlib/transport/ftp.py
- bzrlib/win32utils.py => bzrlib/win32console.py
- bzrlib/xml8.py => bzrlib/xml5.py
- bzrlib/help_topics/en/configuration.txt => doc/configuration.txt
- doc/en/user-guide/index.txt => doc/index.txt
- doc/en/user-guide/plugins.txt => doc/plugins.txt
- doc/en/user-guide/setting_up_email.txt => doc/setting_up_email.txt
- doc/en/user-guide/specifying_revisions.txt => doc/specifying_revisions.txt
- doc/en/tutorials/tutorial.txt => doc/tutorial.txt
- doc/en/user-guide/using_aliases.txt => doc/using_aliases.txt
- tools/generate_docs.py => generate_docs.py
- bzrlib/doc_generate/ => tools/doc_generate/
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006 by 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
"""builtin bzr commands"""
18
18
19
20
import codecs
21
import errno
19
22
import os
20
21
from bzrlib.lazy_import import lazy_import
22
lazy_import(globals(), """
23
import codecs
24
import cStringIO
23
import os.path
25
24
import sys
26
import time
27
25
28
26
import bzrlib
29
27
from bzrlib import (
30
bugtracker,
28
branch,
31
29
bundle,
32
btree_index,
33
30
bzrdir,
34
delta,
35
31
config,
36
32
errors,
37
globbing,
38
hooks,
33
ignores,
39
34
log,
40
merge as _mod_merge,
41
merge_directive,
42
35
osutils,
43
reconfigure,
44
rename_map,
45
revision as _mod_revision,
46
symbol_versioning,
36
repository,
47
37
transport,
48
38
ui,
49
39
urlutils,
50
views,
51
40
)
52
from bzrlib.branch import Branch
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
53
44
from bzrlib.conflicts import ConflictList
54
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
55
from bzrlib.smtp_connection import SMTPConnection
45
from bzrlib.commands import Command, display_command
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
47
NotBranchError, DivergedBranches, NotConflicted,
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
54
from bzrlib.revisionspec import RevisionSpec
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
56
57
from bzrlib.workingtree import WorkingTree
57
""")
58
59
from bzrlib.commands import Command, display_command
60
from bzrlib.option import (
61
ListOption,
62
Option,
63
RegistryOption,
64
custom_help,
65
_parse_revision_str,
66
)
67
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
68
69
70
def tree_files(file_list, default_branch=u'.', canonicalize=True,
71
apply_view=True):
58
59
60
def tree_files(file_list, default_branch=u'.'):
72
61
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]))
78
79
80
def tree_files_for_add(file_list):
81
"""
82
Return a tree and list of absolute paths from a file list.
83
84
Similar to tree_files, but add handles files a bit differently, so it a
85
custom implementation. In particular, MutableTreeTree.smart_add expects
86
absolute paths, which it immediately converts to relative paths.
87
"""
88
# FIXME Would be nice to just return the relative paths like
89
# internal_tree_files does, but there are a large number of unit tests
90
# that assume the current interface to mutabletree.smart_add
91
if file_list:
92
tree, relpath = WorkingTree.open_containing(file_list[0])
93
if tree.supports_views():
94
view_files = tree.views.lookup_view()
95
if view_files:
96
for filename in file_list:
97
if not osutils.is_inside_any(view_files, filename):
98
raise errors.FileOutsideView(filename, view_files)
99
file_list = file_list[:]
100
file_list[0] = tree.abspath(relpath)
101
else:
102
tree = WorkingTree.open_containing(u'.')[0]
103
if tree.supports_views():
104
view_files = tree.views.lookup_view()
105
if view_files:
106
file_list = view_files
107
view_str = views.view_display_str(view_files)
108
note("Ignoring files outside view. View is %s" % view_str)
109
return tree, file_list
110
111
112
def _get_one_revision(command_name, revisions):
113
if revisions is None:
114
return None
115
if len(revisions) != 1:
116
raise errors.BzrCommandError(
117
'bzr %s --revision takes exactly one revision identifier' % (
118
command_name,))
119
return revisions[0]
120
121
122
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
123
if branch is None:
124
branch = tree.branch
125
if revisions is None:
126
if tree is not None:
127
rev_tree = tree.basis_tree()
128
else:
129
rev_tree = branch.basis_tree()
130
else:
131
revision = _get_one_revision(command_name, revisions)
132
rev_tree = revision.as_tree(branch)
133
return rev_tree
62
return internal_tree_files(file_list, default_branch)
63
except FileInWrongBranch, e:
64
raise BzrCommandError("%s is not in the same branch as %s" %
65
(e.path, file_list[0]))
134
66
135
67
136
68
# XXX: Bad function name; should possibly also be a class method of
137
69
# WorkingTree rather than a function.
138
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
139
apply_view=True):
70
def internal_tree_files(file_list, default_branch=u'.'):
140
71
"""Convert command-line paths to a WorkingTree and relative paths.
141
72
142
73
This is typically used for command-line processors that take one or
144
75
145
76
The filenames given are not required to exist.
146
77
147
:param file_list: Filenames to convert.
148
149
:param default_branch: Fallback tree path to use if file_list is empty or
150
None.
151
152
:param apply_view: if True and a view is set, apply it or check that
153
specified files are within it
78
:param file_list: Filenames to convert.
79
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
154
81
155
82
:return: workingtree, [relative_paths]
156
83
"""
157
84
if file_list is None or len(file_list) == 0:
158
tree = WorkingTree.open_containing(default_branch)[0]
159
if tree.supports_views() and apply_view:
160
view_files = tree.views.lookup_view()
161
if view_files:
162
file_list = view_files
163
view_str = views.view_display_str(view_files)
164
note("Ignoring files outside view. View is %s" % view_str)
165
return tree, file_list
166
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
167
return tree, safe_relpath_files(tree, file_list, canonicalize,
168
apply_view=apply_view)
169
170
171
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
172
"""Convert file_list into a list of relpaths in tree.
173
174
:param tree: A tree to operate on.
175
:param file_list: A list of user provided paths or None.
176
:param apply_view: if True and a view is set, apply it or check that
177
specified files are within it
178
:return: A list of relative paths.
179
:raises errors.PathNotChild: When a provided path is in a different tree
180
than tree.
181
"""
182
if file_list is None:
183
return None
184
if tree.supports_views() and apply_view:
185
view_files = tree.views.lookup_view()
186
else:
187
view_files = []
85
return WorkingTree.open_containing(default_branch)[0], file_list
86
tree = WorkingTree.open_containing(file_list[0])[0]
188
87
new_list = []
189
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
190
# doesn't - fix that up here before we enter the loop.
191
if canonicalize:
192
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
193
else:
194
fixer = tree.relpath
195
88
for filename in file_list:
196
89
try:
197
relpath = fixer(osutils.dereference_path(filename))
198
if view_files and not osutils.is_inside_any(view_files, relpath):
199
raise errors.FileOutsideView(filename, view_files)
200
new_list.append(relpath)
90
new_list.append(tree.relpath(filename))
201
91
except errors.PathNotChild:
202
raise errors.FileInWrongBranch(tree.branch, filename)
203
return new_list
204
205
206
def _get_view_info_for_change_reporter(tree):
207
"""Get the view information from a tree for change reporting."""
208
view_info = None
209
try:
210
current_view = tree.views.get_view_info()[0]
211
if current_view is not None:
212
view_info = (current_view, tree.views.lookup_view())
213
except errors.ViewsNotSupported:
214
pass
215
return view_info
92
raise FileInWrongBranch(tree.branch, filename)
93
return tree, new_list
94
95
96
def get_format_type(typestring):
97
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
100
if typestring == "default":
101
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
105
return format
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
109
return format
110
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
111
"metaweave and weave" % typestring
112
raise BzrCommandError(msg)
216
113
217
114
218
115
# TODO: Make sure no commands unconditionally use the working directory as a
242
139
modified
243
140
Text has changed since the previous revision.
244
141
245
kind changed
246
File kind has been changed (e.g. from file to directory).
247
248
142
unknown
249
143
Not versioned and not matching an ignore pattern.
250
144
251
To see ignored files use 'bzr ignored'. For details on the
145
To see ignored files use 'bzr ignored'. For details in the
252
146
changes to file texts, use 'bzr diff'.
253
147
254
Note that --short or -S gives status flags for each item, similar
255
to Subversion's status command. To get output similar to svn -q,
256
use bzr status -SV.
257
258
148
If no arguments are specified, the status of the entire working
259
149
directory is shown. Otherwise, only the status of the specified
260
150
files or directories is reported. If a directory is given, status
261
151
is reported for everything inside that directory.
262
152
263
Before merges are committed, the pending merge tip revisions are
264
shown. To see all pending merge revisions, use the -v option.
265
To skip the display of pending merge information altogether, use
266
the no-pending option or specify a file/directory.
267
268
153
If a revision argument is given, the status is calculated against
269
154
that revision, or between two revisions if two are provided.
270
155
"""
271
156
272
157
# TODO: --no-recurse, --recurse options
273
158
274
159
takes_args = ['file*']
275
takes_options = ['show-ids', 'revision', 'change', 'verbose',
276
Option('short', help='Use short status indicators.',
277
short_name='S'),
278
Option('versioned', help='Only show versioned files.',
279
short_name='V'),
280
Option('no-pending', help='Don\'t show pending merges.',
281
),
282
]
160
takes_options = ['show-ids', 'revision']
283
161
aliases = ['st', 'stat']
284
162
285
163
encoding_type = 'replace'
286
_see_also = ['diff', 'revert', 'status-flags']
287
164
288
165
@display_command
289
def run(self, show_ids=False, file_list=None, revision=None, short=False,
290
versioned=False, no_pending=False, verbose=False):
166
def run(self, show_ids=False, file_list=None, revision=None):
291
167
from bzrlib.status import show_tree_status
292
168
293
if revision and len(revision) > 2:
294
raise errors.BzrCommandError('bzr status --revision takes exactly'
295
' one or two revision specifiers')
296
297
tree, relfile_list = tree_files(file_list)
298
# Avoid asking for specific files when that is not needed.
299
if relfile_list == ['']:
300
relfile_list = None
301
# Don't disable pending merges for full trees other than '.'.
302
if file_list == ['.']:
303
no_pending = True
304
# A specific path within a tree was given.
305
elif relfile_list is not None:
306
no_pending = True
169
tree, file_list = tree_files(file_list)
170
307
171
show_tree_status(tree, show_ids=show_ids,
308
specific_files=relfile_list, revision=revision,
309
to_file=self.outf, short=short, versioned=versioned,
310
show_pending=(not no_pending), verbose=verbose)
172
specific_files=file_list, revision=revision,
173
to_file=self.outf)
311
174
312
175
313
176
class cmd_cat_revision(Command):
314
177
"""Write out metadata for a revision.
315
178
316
179
The revision to print can either be specified by a specific
317
180
revision identifier, or you can use --revision.
318
181
"""
322
185
takes_options = ['revision']
323
186
# cat-revision is more for frontends so should be exact
324
187
encoding = 'strict'
325
188
326
189
@display_command
327
190
def run(self, revision_id=None, revision=None):
191
328
192
if revision_id is not None and revision is not None:
329
raise errors.BzrCommandError('You can only supply one of'
330
' revision_id or --revision')
193
raise BzrCommandError('You can only supply one of revision_id or --revision')
331
194
if revision_id is None and revision is None:
332
raise errors.BzrCommandError('You must supply either'
333
' --revision or a revision_id')
195
raise BzrCommandError('You must supply either --revision or a revision_id')
334
196
b = WorkingTree.open_containing(u'.')[0].branch
335
197
336
198
# TODO: jam 20060112 should cat-revision always output utf-8?
337
199
if revision_id is not None:
338
revision_id = osutils.safe_revision_id(revision_id, warn=False)
339
try:
340
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
341
except errors.NoSuchRevision:
342
msg = "The repository %s contains no revision %s." % (b.repository.base,
343
revision_id)
344
raise errors.BzrCommandError(msg)
200
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
345
201
elif revision is not None:
346
202
for rev in revision:
347
203
if rev is None:
348
raise errors.BzrCommandError('You cannot specify a NULL'
349
' revision.')
350
rev_id = rev.as_revision_id(b)
204
raise BzrCommandError('You cannot specify a NULL revision.')
205
revno, rev_id = rev.in_history(b)
351
206
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
352
353
354
class cmd_dump_btree(Command):
355
"""Dump the contents of a btree index file to stdout.
356
357
PATH is a btree index file, it can be any URL. This includes things like
358
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
359
360
By default, the tuples stored in the index file will be displayed. With
361
--raw, we will uncompress the pages, but otherwise display the raw bytes
362
stored in the index.
363
"""
364
365
# TODO: Do we want to dump the internal nodes as well?
366
# TODO: It would be nice to be able to dump the un-parsed information,
367
# rather than only going through iter_all_entries. However, this is
368
# good enough for a start
369
hidden = True
370
encoding_type = 'exact'
371
takes_args = ['path']
372
takes_options = [Option('raw', help='Write the uncompressed bytes out,'
373
' rather than the parsed tuples.'),
374
]
375
376
def run(self, path, raw=False):
377
dirname, basename = osutils.split(path)
378
t = transport.get_transport(dirname)
379
if raw:
380
self._dump_raw_bytes(t, basename)
381
else:
382
self._dump_entries(t, basename)
383
384
def _get_index_and_bytes(self, trans, basename):
385
"""Create a BTreeGraphIndex and raw bytes."""
386
bt = btree_index.BTreeGraphIndex(trans, basename, None)
387
bytes = trans.get_bytes(basename)
388
bt._file = cStringIO.StringIO(bytes)
389
bt._size = len(bytes)
390
return bt, bytes
391
392
def _dump_raw_bytes(self, trans, basename):
393
import zlib
394
395
# We need to parse at least the root node.
396
# This is because the first page of every row starts with an
397
# uncompressed header.
398
bt, bytes = self._get_index_and_bytes(trans, basename)
399
for page_idx, page_start in enumerate(xrange(0, len(bytes),
400
btree_index._PAGE_SIZE)):
401
page_end = min(page_start + btree_index._PAGE_SIZE, len(bytes))
402
page_bytes = bytes[page_start:page_end]
403
if page_idx == 0:
404
self.outf.write('Root node:\n')
405
header_end, data = bt._parse_header_from_bytes(page_bytes)
406
self.outf.write(page_bytes[:header_end])
407
page_bytes = data
408
self.outf.write('\nPage %d\n' % (page_idx,))
409
decomp_bytes = zlib.decompress(page_bytes)
410
self.outf.write(decomp_bytes)
411
self.outf.write('\n')
412
413
def _dump_entries(self, trans, basename):
414
try:
415
st = trans.stat(basename)
416
except errors.TransportNotPossible:
417
# We can't stat, so we'll fake it because we have to do the 'get()'
418
# anyway.
419
bt, _ = self._get_index_and_bytes(trans, basename)
420
else:
421
bt = btree_index.BTreeGraphIndex(trans, basename, st.st_size)
422
for node in bt.iter_all_entries():
423
# Node is made up of:
424
# (index, key, value, [references])
425
self.outf.write('%s\n' % (node[1:],))
426
427
428
class cmd_remove_tree(Command):
429
"""Remove the working tree from a given branch/checkout.
430
431
Since a lightweight checkout is little more than a working tree
432
this will refuse to run against one.
433
434
To re-create the working tree, use "bzr checkout".
435
"""
436
_see_also = ['checkout', 'working-trees']
437
takes_args = ['location?']
438
takes_options = [
439
Option('force',
440
help='Remove the working tree even if it has '
441
'uncommitted changes.'),
442
]
443
444
def run(self, location='.', force=False):
445
d = bzrdir.BzrDir.open(location)
446
447
try:
448
working = d.open_workingtree()
449
except errors.NoWorkingTree:
450
raise errors.BzrCommandError("No working tree to remove")
451
except errors.NotLocalUrl:
452
raise errors.BzrCommandError("You cannot remove the working tree"
453
" of a remote path")
454
if not force:
455
# XXX: What about pending merges ? -- vila 20090629
456
if working.has_changes(working.basis_tree()):
457
raise errors.UncommittedChanges(working)
458
459
working_path = working.bzrdir.root_transport.base
460
branch_path = working.branch.bzrdir.root_transport.base
461
if working_path != branch_path:
462
raise errors.BzrCommandError("You cannot remove the working tree"
463
" from a lightweight checkout")
464
465
d.destroy_workingtree()
466
207
467
208
468
209
class cmd_revno(Command):
469
210
"""Show current revision number.
471
212
This is equal to the number of revisions on this branch.
472
213
"""
473
214
474
_see_also = ['info']
475
215
takes_args = ['location?']
476
takes_options = [
477
Option('tree', help='Show revno of working tree'),
478
]
479
216
480
217
@display_command
481
def run(self, tree=False, location=u'.'):
482
if tree:
483
try:
484
wt = WorkingTree.open_containing(location)[0]
485
wt.lock_read()
486
except (errors.NoWorkingTree, errors.NotLocalUrl):
487
raise errors.NoWorkingTree(location)
488
try:
489
revid = wt.last_revision()
490
try:
491
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
492
except errors.NoSuchRevision:
493
revno_t = ('???',)
494
revno = ".".join(str(n) for n in revno_t)
495
finally:
496
wt.unlock()
497
else:
498
b = Branch.open_containing(location)[0]
499
b.lock_read()
500
try:
501
revno = b.revno()
502
finally:
503
b.unlock()
504
505
self.outf.write(str(revno) + '\n')
218
def run(self, location=u'.'):
219
self.outf.write(str(Branch.open_containing(location)[0].revno()))
220
self.outf.write('\n')
506
221
507
222
508
223
class cmd_revision_info(Command):
510
225
"""
511
226
hidden = True
512
227
takes_args = ['revision_info*']
513
takes_options = [
514
'revision',
515
Option('directory',
516
help='Branch to examine, '
517
'rather than the one containing the working directory.',
518
short_name='d',
519
type=unicode,
520
),
521
Option('tree', help='Show revno of working tree'),
522
]
228
takes_options = ['revision']
523
229
524
230
@display_command
525
def run(self, revision=None, directory=u'.', tree=False,
526
revision_info_list=[]):
527
528
try:
529
wt = WorkingTree.open_containing(directory)[0]
530
b = wt.branch
531
wt.lock_read()
532
except (errors.NoWorkingTree, errors.NotLocalUrl):
533
wt = None
534
b = Branch.open_containing(directory)[0]
535
b.lock_read()
536
try:
537
revision_ids = []
538
if revision is not None:
539
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
540
if revision_info_list is not None:
541
for rev_str in revision_info_list:
542
rev_spec = RevisionSpec.from_string(rev_str)
543
revision_ids.append(rev_spec.as_revision_id(b))
544
# No arguments supplied, default to the last revision
545
if len(revision_ids) == 0:
546
if tree:
547
if wt is None:
548
raise errors.NoWorkingTree(directory)
549
revision_ids.append(wt.last_revision())
550
else:
551
revision_ids.append(b.last_revision())
552
553
revinfos = []
554
maxlen = 0
555
for revision_id in revision_ids:
556
try:
557
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
558
revno = '.'.join(str(i) for i in dotted_revno)
559
except errors.NoSuchRevision:
560
revno = '???'
561
maxlen = max(maxlen, len(revno))
562
revinfos.append([revno, revision_id])
563
finally:
564
if wt is None:
565
b.unlock()
231
def run(self, revision=None, revision_info_list=[]):
232
233
revs = []
234
if revision is not None:
235
revs.extend(revision)
236
if revision_info_list is not None:
237
for rev in revision_info_list:
238
revs.append(RevisionSpec(rev))
239
if len(revs) == 0:
240
raise BzrCommandError('You must supply a revision identifier')
241
242
b = WorkingTree.open_containing(u'.')[0].branch
243
244
for rev in revs:
245
revinfo = rev.in_history(b)
246
if revinfo.revno is None:
247
print ' %s' % revinfo.rev_id
566
248
else:
567
wt.unlock()
568
569
for ri in revinfos:
570
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
571
572
249
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
250
251
573
252
class cmd_add(Command):
574
253
"""Add specified files or directories.
575
254
593
272
you should never need to explicitly add a directory, they'll just
594
273
get added when you add a file in the directory.
595
274
596
--dry-run will show which files would be added, but not actually
275
--dry-run will show which files would be added, but not actually
597
276
add them.
598
599
--file-ids-from will try to use the file ids from the supplied path.
600
It looks up ids trying to find a matching parent directory with the
601
same filename, and then by pure path. This option is rarely needed
602
but can be useful when adding the same logical file into two
603
branches that will be merged later (without showing the two different
604
adds as a conflict). It is also useful when merging another project
605
into a subdirectory of this one.
606
277
"""
607
278
takes_args = ['file*']
608
takes_options = [
609
Option('no-recurse',
610
help="Don't recursively add the contents of directories."),
611
Option('dry-run',
612
help="Show what would be done, but don't actually do anything."),
613
'verbose',
614
Option('file-ids-from',
615
type=unicode,
616
help='Lookup file ids from this tree.'),
617
]
279
takes_options = ['no-recurse', 'dry-run', 'verbose']
618
280
encoding_type = 'replace'
619
_see_also = ['remove']
620
281
621
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
622
file_ids_from=None):
282
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
623
283
import bzrlib.add
624
284
625
base_tree = None
626
if file_ids_from is not None:
627
try:
628
base_tree, base_path = WorkingTree.open_containing(
629
file_ids_from)
630
except errors.NoWorkingTree:
631
base_branch, base_path = Branch.open_containing(
632
file_ids_from)
633
base_tree = base_branch.basis_tree()
634
635
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
636
to_file=self.outf, should_print=(not is_quiet()))
637
else:
638
action = bzrlib.add.AddAction(to_file=self.outf,
639
should_print=(not is_quiet()))
640
641
if base_tree:
642
base_tree.lock_read()
643
try:
644
file_list = self._maybe_expand_globs(file_list)
645
tree, file_list = tree_files_for_add(file_list)
646
added, ignored = tree.smart_add(file_list, not
647
no_recurse, action=action, save=not dry_run)
648
finally:
649
if base_tree is not None:
650
base_tree.unlock()
285
action = bzrlib.add.AddAction(to_file=self.outf,
286
should_print=(not is_quiet()))
287
288
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
289
action=action, save=not dry_run)
651
290
if len(ignored) > 0:
652
291
if verbose:
653
292
for glob in sorted(ignored.keys()):
654
293
for path in ignored[glob]:
655
self.outf.write("ignored %s matching \"%s\"\n"
294
self.outf.write("ignored %s matching \"%s\"\n"
656
295
% (path, glob))
657
296
else:
658
297
match_len = 0
659
298
for glob, paths in ignored.items():
660
299
match_len += len(paths)
661
300
self.outf.write("ignored %d file(s).\n" % match_len)
662
self.outf.write("If you wish to add ignored files, "
663
"please add them explicitly by name. "
664
"(\"bzr ignored\" gives a list)\n")
301
self.outf.write("If you wish to add some of these files,"
302
" please add them by name.\n")
665
303
666
304
667
305
class cmd_mkdir(Command):
686
324
687
325
takes_args = ['filename']
688
326
hidden = True
689
327
690
328
@display_command
691
329
def run(self, filename):
692
330
# TODO: jam 20050106 Can relpath return a munged path if
700
338
"""Show inventory of the current working copy or a revision.
701
339
702
340
It is possible to limit the output to a particular entry
703
type using the --kind option. For example: --kind file.
704
705
It is also possible to restrict the list of files to a specific
706
set. For example: bzr inventory --show-ids this/file
341
type using the --kind option. For example; --kind file.
707
342
"""
708
343
709
hidden = True
710
_see_also = ['ls']
711
takes_options = [
712
'revision',
713
'show-ids',
714
Option('kind',
715
help='List entries of a particular kind: file, directory, symlink.',
716
type=unicode),
717
]
718
takes_args = ['file*']
719
344
takes_options = ['revision', 'show-ids', 'kind']
345
720
346
@display_command
721
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
347
def run(self, revision=None, show_ids=False, kind=None):
722
348
if kind and kind not in ['file', 'directory', 'symlink']:
723
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
724
725
revision = _get_one_revision('inventory', revision)
726
work_tree, file_list = tree_files(file_list)
727
work_tree.lock_read()
728
try:
729
if revision is not None:
730
tree = revision.as_tree(work_tree.branch)
731
732
extra_trees = [work_tree]
733
tree.lock_read()
734
else:
735
tree = work_tree
736
extra_trees = []
737
738
if file_list is not None:
739
file_ids = tree.paths2ids(file_list, trees=extra_trees,
740
require_versioned=True)
741
# find_ids_across_trees may include some paths that don't
742
# exist in 'tree'.
743
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
744
for file_id in file_ids if file_id in tree)
745
else:
746
entries = tree.inventory.entries()
747
finally:
748
tree.unlock()
749
if tree is not work_tree:
750
work_tree.unlock()
751
752
for path, entry in entries:
349
raise BzrCommandError('invalid kind specified')
350
tree = WorkingTree.open_containing(u'.')[0]
351
if revision is None:
352
inv = tree.read_working_inventory()
353
else:
354
if len(revision) > 1:
355
raise BzrCommandError('bzr inventory --revision takes'
356
' exactly one revision identifier')
357
inv = tree.branch.repository.get_revision_inventory(
358
revision[0].in_history(tree.branch).rev_id)
359
360
for path, entry in inv.entries():
753
361
if kind and kind != entry.kind:
754
362
continue
755
363
if show_ids:
762
370
class cmd_mv(Command):
763
371
"""Move or rename a file.
764
372
765
:Usage:
373
usage:
766
374
bzr mv OLDNAME NEWNAME
767
768
375
bzr mv SOURCE... DESTINATION
769
376
770
377
If the last argument is a versioned directory, all the other names
771
378
are moved into it. Otherwise, there must be exactly two arguments
772
and the file is changed to a new name.
773
774
If OLDNAME does not exist on the filesystem but is versioned and
775
NEWNAME does exist on the filesystem but is not versioned, mv
776
assumes that the file has been manually moved and only updates
777
its internal inventory to reflect that change.
778
The same is valid when moving many SOURCE files to a DESTINATION.
379
and the file is changed to a new name, which must not already exist.
779
380
780
381
Files cannot be moved between branches.
781
382
"""
782
383
783
384
takes_args = ['names*']
784
takes_options = [Option("after", help="Move only the bzr identifier"
785
" of the file, because the file has already been moved."),
786
Option('auto', help='Automatically guess renames.'),
787
Option('dry-run', help='Avoid making changes when guessing renames.'),
788
]
789
385
aliases = ['move', 'rename']
790
386
encoding_type = 'replace'
791
387
792
def run(self, names_list, after=False, auto=False, dry_run=False):
793
if auto:
794
return self.run_auto(names_list, after, dry_run)
795
elif dry_run:
796
raise errors.BzrCommandError('--dry-run requires --auto.')
388
def run(self, names_list):
797
389
if names_list is None:
798
390
names_list = []
391
799
392
if len(names_list) < 2:
800
raise errors.BzrCommandError("missing file argument")
801
tree, rel_names = tree_files(names_list, canonicalize=False)
802
tree.lock_tree_write()
803
try:
804
self._run(tree, names_list, rel_names, after)
805
finally:
806
tree.unlock()
807
808
def run_auto(self, names_list, after, dry_run):
809
if names_list is not None and len(names_list) > 1:
810
raise errors.BzrCommandError('Only one path may be specified to'
811
' --auto.')
812
if after:
813
raise errors.BzrCommandError('--after cannot be specified with'
814
' --auto.')
815
work_tree, file_list = tree_files(names_list, default_branch='.')
816
work_tree.lock_tree_write()
817
try:
818
rename_map.RenameMap.guess_renames(work_tree, dry_run)
819
finally:
820
work_tree.unlock()
821
822
def _run(self, tree, names_list, rel_names, after):
823
into_existing = osutils.isdir(names_list[-1])
824
if into_existing and len(names_list) == 2:
825
# special cases:
826
# a. case-insensitive filesystem and change case of dir
827
# b. move directory after the fact (if the source used to be
828
# a directory, but now doesn't exist in the working tree
829
# and the target is an existing directory, just rename it)
830
if (not tree.case_sensitive
831
and rel_names[0].lower() == rel_names[1].lower()):
832
into_existing = False
833
else:
834
inv = tree.inventory
835
# 'fix' the case of a potential 'from'
836
from_id = tree.path2id(
837
tree.get_canonical_inventory_path(rel_names[0]))
838
if (not osutils.lexists(names_list[0]) and
839
from_id and inv.get_file_kind(from_id) == "directory"):
840
into_existing = False
841
# move/rename
842
if into_existing:
393
raise BzrCommandError("missing file argument")
394
tree, rel_names = tree_files(names_list)
395
396
if os.path.isdir(names_list[-1]):
843
397
# move into existing directory
844
# All entries reference existing inventory items, so fix them up
845
# for cicp file-systems.
846
rel_names = tree.get_canonical_inventory_paths(rel_names)
847
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
398
for pair in tree.move(rel_names[:-1], rel_names[-1]):
848
399
self.outf.write("%s => %s\n" % pair)
849
400
else:
850
401
if len(names_list) != 2:
851
raise errors.BzrCommandError('to mv multiple files the'
852
' destination must be a versioned'
853
' directory')
854
855
# for cicp file-systems: the src references an existing inventory
856
# item:
857
src = tree.get_canonical_inventory_path(rel_names[0])
858
# Find the canonical version of the destination: In all cases, the
859
# parent of the target must be in the inventory, so we fetch the
860
# canonical version from there (we do not always *use* the
861
# canonicalized tail portion - we may be attempting to rename the
862
# case of the tail)
863
canon_dest = tree.get_canonical_inventory_path(rel_names[1])
864
dest_parent = osutils.dirname(canon_dest)
865
spec_tail = osutils.basename(rel_names[1])
866
# For a CICP file-system, we need to avoid creating 2 inventory
867
# entries that differ only by case. So regardless of the case
868
# we *want* to use (ie, specified by the user or the file-system),
869
# we must always choose to use the case of any existing inventory
870
# items. The only exception to this is when we are attempting a
871
# case-only rename (ie, canonical versions of src and dest are
872
# the same)
873
dest_id = tree.path2id(canon_dest)
874
if dest_id is None or tree.path2id(src) == dest_id:
875
# No existing item we care about, so work out what case we
876
# are actually going to use.
877
if after:
878
# If 'after' is specified, the tail must refer to a file on disk.
879
if dest_parent:
880
dest_parent_fq = osutils.pathjoin(tree.basedir, dest_parent)
881
else:
882
# pathjoin with an empty tail adds a slash, which breaks
883
# relpath :(
884
dest_parent_fq = tree.basedir
885
886
dest_tail = osutils.canonical_relpath(
887
dest_parent_fq,
888
osutils.pathjoin(dest_parent_fq, spec_tail))
889
else:
890
# not 'after', so case as specified is used
891
dest_tail = spec_tail
892
else:
893
# Use the existing item so 'mv' fails with AlreadyVersioned.
894
dest_tail = os.path.basename(canon_dest)
895
dest = osutils.pathjoin(dest_parent, dest_tail)
896
mutter("attempting to move %s => %s", src, dest)
897
tree.rename_one(src, dest, after=after)
898
self.outf.write("%s => %s\n" % (src, dest))
899
900
402
raise BzrCommandError('to mv multiple files the destination '
403
'must be a versioned directory')
404
tree.rename_one(rel_names[0], rel_names[1])
405
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
406
407
901
408
class cmd_pull(Command):
902
409
"""Turn this branch into a mirror of another branch.
903
410
916
423
that, you can omit the location to use the default. To change the
917
424
default, use --remember. The value will only be saved if the remote
918
425
location can be accessed.
919
920
Note: The location can be specified either in the form of a branch,
921
or in the form of a path to a file containing a merge directive generated
922
with bzr send.
923
426
"""
924
427
925
_see_also = ['push', 'update', 'status-flags', 'send']
926
takes_options = ['remember', 'overwrite', 'revision',
927
custom_help('verbose',
928
help='Show logs of pulled revisions.'),
929
Option('directory',
930
help='Branch to pull into, '
931
'rather than the one containing the working directory.',
932
short_name='d',
933
type=unicode,
934
),
935
Option('local',
936
help="Perform a local pull in a bound "
937
"branch. Local pulls are not applied to "
938
"the master branch."
939
),
940
]
428
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
941
429
takes_args = ['location?']
942
430
encoding_type = 'replace'
943
431
944
def run(self, location=None, remember=False, overwrite=False,
945
revision=None, verbose=False,
946
directory=None, local=False):
432
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
947
433
# FIXME: too much stuff is in the command class
948
revision_id = None
949
mergeable = None
950
if directory is None:
951
directory = u'.'
952
434
try:
953
tree_to = WorkingTree.open_containing(directory)[0]
435
tree_to = WorkingTree.open_containing(u'.')[0]
954
436
branch_to = tree_to.branch
955
except errors.NoWorkingTree:
437
except NoWorkingTree:
956
438
tree_to = None
957
branch_to = Branch.open_containing(directory)[0]
958
959
if local and not branch_to.get_bound_location():
960
raise errors.LocalRequiresBoundBranch()
439
branch_to = Branch.open_containing(u'.')[0]
961
440
962
possible_transports = []
441
reader = None
963
442
if location is not None:
964
443
try:
965
mergeable = bundle.read_mergeable_from_url(location,
966
possible_transports=possible_transports)
967
except errors.NotABundle:
968
mergeable = None
444
reader = bundle.read_bundle_from_url(location)
445
except NotABundle:
446
pass # Continue on considering this url a Branch
969
447
970
448
stored_loc = branch_to.get_parent()
971
449
if location is None:
972
450
if stored_loc is None:
973
raise errors.BzrCommandError("No pull location known or"
974
" specified.")
451
raise BzrCommandError("No pull location known or specified.")
975
452
else:
976
453
display_url = urlutils.unescape_for_display(stored_loc,
977
454
self.outf.encoding)
978
if not is_quiet():
979
self.outf.write("Using saved parent location: %s\n" % display_url)
455
self.outf.write("Using saved location: %s\n" % display_url)
980
456
location = stored_loc
981
457
982
revision = _get_one_revision('pull', revision)
983
if mergeable is not None:
984
if revision is not None:
985
raise errors.BzrCommandError(
986
'Cannot use -r with merge directives or bundles')
987
mergeable.install_revisions(branch_to.repository)
988
base_revision_id, revision_id, verified = \
989
mergeable.get_merge_request(branch_to.repository)
458
459
if reader is not None:
460
install_bundle(branch_to.repository, reader)
990
461
branch_from = branch_to
991
462
else:
992
branch_from = Branch.open(location,
993
possible_transports=possible_transports)
463
branch_from = Branch.open(location)
994
464
995
465
if branch_to.get_parent() is None or remember:
996
466
branch_to.set_parent(branch_from.base)
997
467
998
if branch_from is not branch_to:
999
branch_from.lock_read()
1000
try:
1001
if revision is not None:
1002
revision_id = revision.as_revision_id(branch_from)
1003
1004
branch_to.lock_write()
1005
try:
1006
if tree_to is not None:
1007
view_info = _get_view_info_for_change_reporter(tree_to)
1008
change_reporter = delta._ChangeReporter(
1009
unversioned_filter=tree_to.is_ignored,
1010
view_info=view_info)
1011
result = tree_to.pull(
1012
branch_from, overwrite, revision_id, change_reporter,
1013
possible_transports=possible_transports, local=local)
1014
else:
1015
result = branch_to.pull(
1016
branch_from, overwrite, revision_id, local=local)
1017
1018
result.report(self.outf)
1019
if verbose and result.old_revid != result.new_revid:
1020
log.show_branch_change(
1021
branch_to, self.outf, result.old_revno,
1022
result.old_revid)
1023
finally:
1024
branch_to.unlock()
1025
finally:
1026
if branch_from is not branch_to:
1027
branch_from.unlock()
468
rev_id = None
469
if revision is None:
470
if reader is not None:
471
rev_id = reader.target
472
elif len(revision) == 1:
473
rev_id = revision[0].in_history(branch_from).rev_id
474
else:
475
raise BzrCommandError('bzr pull --revision takes one value.')
476
477
old_rh = branch_to.revision_history()
478
if tree_to is not None:
479
count = tree_to.pull(branch_from, overwrite, rev_id)
480
else:
481
count = branch_to.pull(branch_from, overwrite, rev_id)
482
note('%d revision(s) pulled.' % (count,))
483
484
if verbose:
485
new_rh = branch_to.revision_history()
486
if old_rh != new_rh:
487
# Something changed
488
from bzrlib.log import show_changed_revisions
489
show_changed_revisions(branch_to, old_rh, new_rh,
490
to_file=self.outf)
1028
491
1029
492
1030
493
class cmd_push(Command):
1031
494
"""Update a mirror of this branch.
1032
495
1033
496
The target branch will not have its working tree populated because this
1034
497
is both expensive, and is not supported on remote file systems.
1035
498
1036
499
Some smart servers or protocols *may* put the working tree in place in
1037
500
the future.
1038
501
1042
505
1043
506
If branches have diverged, you can use 'bzr push --overwrite' to replace
1044
507
the other branch completely, discarding its unmerged changes.
1045
508
1046
509
If you want to ensure you have the different changes in the other branch,
1047
510
do a merge (see bzr help merge) from the other branch, and commit that.
1048
511
After that you will be able to do a push without '--overwrite'.
1053
516
location can be accessed.
1054
517
"""
1055
518
1056
_see_also = ['pull', 'update', 'working-trees']
1057
takes_options = ['remember', 'overwrite', 'verbose', 'revision',
1058
Option('create-prefix',
1059
help='Create the path leading up to the branch '
1060
'if it does not already exist.'),
1061
Option('directory',
1062
help='Branch to push from, '
1063
'rather than the one containing the working directory.',
1064
short_name='d',
1065
type=unicode,
1066
),
1067
Option('use-existing-dir',
1068
help='By default push will fail if the target'
1069
' directory exists, but does not already'
1070
' have a control directory. This flag will'
1071
' allow push to proceed.'),
1072
Option('stacked',
1073
help='Create a stacked branch that references the public location '
1074
'of the parent branch.'),
1075
Option('stacked-on',
1076
help='Create a stacked branch that refers to another branch '
1077
'for the commit history. Only the work not present in the '
1078
'referenced branch is included in the branch created.',
1079
type=unicode),
1080
Option('strict',
1081
help='Refuse to push if there are uncommitted changes in'
1082
' the working tree, --no-strict disables the check.'),
1083
]
519
takes_options = ['remember', 'overwrite', 'verbose',
520
Option('create-prefix',
521
help='Create the path leading up to the branch '
522
'if it does not already exist')]
1084
523
takes_args = ['location?']
1085
524
encoding_type = 'replace'
1086
525
1087
526
def run(self, location=None, remember=False, overwrite=False,
1088
create_prefix=False, verbose=False, revision=None,
1089
use_existing_dir=False, directory=None, stacked_on=None,
1090
stacked=False, strict=None):
1091
from bzrlib.push import _show_push_branch
1092
1093
if directory is None:
1094
directory = '.'
1095
# Get the source branch
1096
(tree, br_from,
1097
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1098
if strict is None:
1099
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1100
if strict is None: strict = True # default value
1101
# Get the tip's revision_id
1102
revision = _get_one_revision('push', revision)
1103
if revision is not None:
1104
revision_id = revision.in_history(br_from).rev_id
1105
else:
1106
revision_id = None
1107
if strict and tree is not None and revision_id is None:
1108
if (tree.has_changes(tree.basis_tree())
1109
or len(tree.get_parent_ids()) > 1):
1110
raise errors.UncommittedChanges(
1111
tree, more='Use --no-strict to force the push.')
1112
if tree.last_revision() != tree.branch.last_revision():
1113
# The tree has lost sync with its branch, there is little
1114
# chance that the user is aware of it but he can still force
1115
# the push with --no-strict
1116
raise errors.OutOfDateTree(
1117
tree, more='Use --no-strict to force the push.')
1118
1119
# Get the stacked_on branch, if any
1120
if stacked_on is not None:
1121
stacked_on = urlutils.normalize_url(stacked_on)
1122
elif stacked:
1123
parent_url = br_from.get_parent()
1124
if parent_url:
1125
parent = Branch.open(parent_url)
1126
stacked_on = parent.get_public_branch()
1127
if not stacked_on:
1128
# I considered excluding non-http url's here, thus forcing
1129
# 'public' branches only, but that only works for some
1130
# users, so it's best to just depend on the user spotting an
1131
# error by the feedback given to them. RBC 20080227.
1132
stacked_on = parent_url
1133
if not stacked_on:
1134
raise errors.BzrCommandError(
1135
"Could not determine branch to refer to.")
1136
1137
# Get the destination location
527
create_prefix=False, verbose=False):
528
# FIXME: Way too big! Put this into a function called from the
529
# command.
530
531
br_from = Branch.open_containing('.')[0]
532
stored_loc = br_from.get_push_location()
1138
533
if location is None:
1139
stored_loc = br_from.get_push_location()
1140
534
if stored_loc is None:
1141
raise errors.BzrCommandError(
1142
"No push location known or specified.")
535
raise BzrCommandError("No push location known or specified.")
1143
536
else:
1144
537
display_url = urlutils.unescape_for_display(stored_loc,
1145
538
self.outf.encoding)
1146
self.outf.write("Using saved push location: %s\n" % display_url)
539
self.outf.write("Using saved location: %s\n" % display_url)
1147
540
location = stored_loc
1148
541
1149
_show_push_branch(br_from, revision_id, location, self.outf,
1150
verbose=verbose, overwrite=overwrite, remember=remember,
1151
stacked_on=stacked_on, create_prefix=create_prefix,
1152
use_existing_dir=use_existing_dir)
542
to_transport = transport.get_transport(location)
543
location_url = to_transport.base
544
545
old_rh = []
546
try:
547
dir_to = bzrdir.BzrDir.open(location_url)
548
br_to = dir_to.open_branch()
549
except NotBranchError:
550
# create a branch.
551
to_transport = to_transport.clone('..')
552
if not create_prefix:
553
try:
554
relurl = to_transport.relpath(location_url)
555
mutter('creating directory %s => %s', location_url, relurl)
556
to_transport.mkdir(relurl)
557
except NoSuchFile:
558
raise BzrCommandError("Parent directory of %s "
559
"does not exist." % location)
560
else:
561
current = to_transport.base
562
needed = [(to_transport, to_transport.relpath(location_url))]
563
while needed:
564
try:
565
to_transport, relpath = needed[-1]
566
to_transport.mkdir(relpath)
567
needed.pop()
568
except NoSuchFile:
569
new_transport = to_transport.clone('..')
570
needed.append((new_transport,
571
new_transport.relpath(to_transport.base)))
572
if new_transport.base == to_transport.base:
573
raise BzrCommandError("Could not create "
574
"path prefix.")
575
dir_to = br_from.bzrdir.clone(location_url,
576
revision_id=br_from.last_revision())
577
br_to = dir_to.open_branch()
578
count = len(br_to.revision_history())
579
# We successfully created the target, remember it
580
if br_from.get_push_location() is None or remember:
581
br_from.set_push_location(br_to.base)
582
else:
583
# We were able to connect to the remote location, so remember it
584
# we don't need to successfully push because of possible divergence.
585
if br_from.get_push_location() is None or remember:
586
br_from.set_push_location(br_to.base)
587
old_rh = br_to.revision_history()
588
try:
589
try:
590
tree_to = dir_to.open_workingtree()
591
except errors.NotLocalUrl:
592
warning('This transport does not update the working '
593
'tree of: %s' % (br_to.base,))
594
count = br_to.pull(br_from, overwrite)
595
except NoWorkingTree:
596
count = br_to.pull(br_from, overwrite)
597
else:
598
count = tree_to.pull(br_from, overwrite)
599
except DivergedBranches:
600
raise BzrCommandError("These branches have diverged."
601
" Try a merge then push with overwrite.")
602
note('%d revision(s) pushed.' % (count,))
603
604
if verbose:
605
new_rh = br_to.revision_history()
606
if old_rh != new_rh:
607
# Something changed
608
from bzrlib.log import show_changed_revisions
609
show_changed_revisions(br_to, old_rh, new_rh,
610
to_file=self.outf)
1153
611
1154
612
1155
613
class cmd_branch(Command):
1156
"""Create a new branch that is a copy of an existing branch.
614
"""Create a new copy of a branch.
1157
615
1158
616
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1159
617
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1160
If the FROM_LOCATION has no / or path separator embedded, the TO_LOCATION
1161
is derived from the FROM_LOCATION by stripping a leading scheme or drive
1162
identifier, if any. For example, "branch lp:foo-bar" will attempt to
1163
create ./foo-bar.
1164
618
1165
619
To retrieve the branch as of a particular revision, supply the --revision
1166
620
parameter, as in "branch foo/bar -r 5".
621
622
--basis is to speed up branching from remote branches. When specified, it
623
copies all the file-contents, inventory and revision data from the basis
624
branch before copying anything from the remote branch.
1167
625
"""
1168
1169
_see_also = ['checkout']
1170
626
takes_args = ['from_location', 'to_location?']
1171
takes_options = ['revision', Option('hardlink',
1172
help='Hard-link working tree files where possible.'),
1173
Option('no-tree',
1174
help="Create a branch without a working-tree."),
1175
Option('stacked',
1176
help='Create a stacked branch referring to the source branch. '
1177
'The new branch will depend on the availability of the source '
1178
'branch for all operations.'),
1179
Option('standalone',
1180
help='Do not use a shared repository, even if available.'),
1181
Option('use-existing-dir',
1182
help='By default branch will fail if the target'
1183
' directory exists, but does not already'
1184
' have a control directory. This flag will'
1185
' allow branch to proceed.'),
1186
]
627
takes_options = ['revision', 'basis']
1187
628
aliases = ['get', 'clone']
1188
629
1189
def run(self, from_location, to_location=None, revision=None,
1190
hardlink=False, stacked=False, standalone=False, no_tree=False,
1191
use_existing_dir=False):
1192
from bzrlib.tag import _merge_tags_if_possible
1193
1194
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1195
from_location)
1196
if (accelerator_tree is not None and
1197
accelerator_tree.supports_content_filtering()):
1198
accelerator_tree = None
1199
revision = _get_one_revision('branch', revision)
630
def run(self, from_location, to_location=None, revision=None, basis=None):
631
if revision is None:
632
revision = [None]
633
elif len(revision) > 1:
634
raise BzrCommandError(
635
'bzr branch --revision takes exactly 1 revision value')
636
try:
637
br_from = Branch.open(from_location)
638
except OSError, e:
639
if e.errno == errno.ENOENT:
640
raise BzrCommandError('Source location "%s" does not'
641
' exist.' % to_location)
642
else:
643
raise
1200
644
br_from.lock_read()
1201
645
try:
1202
if revision is not None:
1203
revision_id = revision.as_revision_id(br_from)
646
if basis is not None:
647
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
648
else:
649
basis_dir = None
650
if len(revision) == 1 and revision[0] is not None:
651
revision_id = revision[0].in_history(br_from)[1]
1204
652
else:
1205
653
# FIXME - wt.last_revision, fallback to branch, fall back to
1206
654
# None or perhaps NULL_REVISION to mean copy nothing
1207
655
# RBC 20060209
1208
656
revision_id = br_from.last_revision()
1209
657
if to_location is None:
1210
to_location = urlutils.derive_to_location(from_location)
658
to_location = os.path.basename(from_location.rstrip("/\\"))
659
name = None
660
else:
661
name = os.path.basename(to_location) + '\n'
662
1211
663
to_transport = transport.get_transport(to_location)
1212
664
try:
1213
665
to_transport.mkdir('.')
1214
666
except errors.FileExists:
1215
if not use_existing_dir:
1216
raise errors.BzrCommandError('Target directory "%s" '
1217
'already exists.' % to_location)
1218
else:
1219
try:
1220
bzrdir.BzrDir.open_from_transport(to_transport)
1221
except errors.NotBranchError:
1222
pass
1223
else:
1224
raise errors.AlreadyBranchError(to_location)
667
raise BzrCommandError('Target directory "%s" already'
668
' exists.' % to_location)
1225
669
except errors.NoSuchFile:
1226
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1227
% to_location)
670
raise BzrCommandError('Parent of "%s" does not exist.' %
671
to_location)
1228
672
try:
1229
673
# preserve whatever source format we have.
1230
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1231
possible_transports=[to_transport],
1232
accelerator_tree=accelerator_tree,
1233
hardlink=hardlink, stacked=stacked,
1234
force_new_repo=standalone,
1235
create_tree_if_local=not no_tree,
1236
source_branch=br_from)
674
dir = br_from.bzrdir.sprout(to_transport.base,
675
revision_id, basis_dir)
1237
676
branch = dir.open_branch()
1238
677
except errors.NoSuchRevision:
1239
678
to_transport.delete_tree('.')
1240
msg = "The branch %s has no revision %s." % (from_location,
1241
revision)
1242
raise errors.BzrCommandError(msg)
1243
_merge_tags_if_possible(br_from, branch)
1244
# If the source branch is stacked, the new branch may
1245
# be stacked whether we asked for that explicitly or not.
1246
# We therefore need a try/except here and not just 'if stacked:'
1247
try:
1248
note('Created new stacked branch referring to %s.' %
1249
branch.get_stacked_on_url())
1250
except (errors.NotStacked, errors.UnstackableBranchFormat,
1251
errors.UnstackableRepositoryFormat), e:
1252
note('Branched %d revision(s).' % branch.revno())
679
msg = "The branch %s has no revision %s." % (from_location, revision[0])
680
raise BzrCommandError(msg)
681
except errors.UnlistableBranch:
682
osutils.rmtree(to_location)
683
msg = "The branch %s cannot be used as a --basis" % (basis,)
684
raise BzrCommandError(msg)
685
if name:
686
branch.control_files.put_utf8('branch-name', name)
687
note('Branched %d revision(s).' % branch.revno())
1253
688
finally:
1254
689
br_from.unlock()
1255
690
1261
696
the branch found in '.'. This is useful if you have removed the working tree
1262
697
or if it was never created - i.e. if you pushed the branch to its current
1263
698
location using SFTP.
1264
699
1265
700
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
1266
701
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
1267
If the BRANCH_LOCATION has no / or path separator embedded, the TO_LOCATION
1268
is derived from the BRANCH_LOCATION by stripping a leading scheme or drive
1269
identifier, if any. For example, "checkout lp:foo-bar" will attempt to
1270
create ./foo-bar.
1271
702
1272
703
To retrieve the branch as of a particular revision, supply the --revision
1273
704
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
1274
705
out of date [so you cannot commit] but it may be useful (i.e. to examine old
1275
706
code.)
707
708
--basis is to speed up checking out from remote branches. When specified, it
709
uses the inventory and file contents from the basis branch in preference to the
710
branch being checked out.
1276
711
"""
1277
1278
_see_also = ['checkouts', 'branch']
1279
712
takes_args = ['branch_location?', 'to_location?']
1280
takes_options = ['revision',
713
takes_options = ['revision', # , 'basis']
1281
714
Option('lightweight',
1282
help="Perform a lightweight checkout. Lightweight "
715
help="perform a lightweight checkout. Lightweight "
1283
716
"checkouts depend on access to the branch for "
1284
"every operation. Normal checkouts can perform "
717
"every operation. Normal checkouts can perform "
1285
718
"common operations like diff and status without "
1286
719
"such access, and also support local commits."
1287
720
),
1288
Option('files-from', type=str,
1289
help="Get file contents from this tree."),
1290
Option('hardlink',
1291
help='Hard-link working tree files where possible.'
1292
),
1293
721
]
1294
722
aliases = ['co']
1295
723
1296
def run(self, branch_location=None, to_location=None, revision=None,
1297
lightweight=False, files_from=None, hardlink=False):
724
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
725
lightweight=False):
726
if revision is None:
727
revision = [None]
728
elif len(revision) > 1:
729
raise BzrCommandError(
730
'bzr checkout --revision takes exactly 1 revision value')
1298
731
if branch_location is None:
1299
732
branch_location = osutils.getcwd()
1300
733
to_location = branch_location
1301
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1302
branch_location)
1303
revision = _get_one_revision('checkout', revision)
1304
if files_from is not None:
1305
accelerator_tree = WorkingTree.open(files_from)
1306
if revision is not None:
1307
revision_id = revision.as_revision_id(source)
734
source = Branch.open(branch_location)
735
if len(revision) == 1 and revision[0] is not None:
736
revision_id = revision[0].in_history(source)[1]
1308
737
else:
1309
738
revision_id = None
1310
739
if to_location is None:
1311
to_location = urlutils.derive_to_location(branch_location)
1312
# if the source and to_location are the same,
740
to_location = os.path.basename(branch_location.rstrip("/\\"))
741
# if the source and to_location are the same,
1313
742
# and there is no working tree,
1314
743
# then reconstitute a branch
1315
if (osutils.abspath(to_location) ==
744
if (osutils.abspath(to_location) ==
1316
745
osutils.abspath(branch_location)):
1317
746
try:
1318
747
source.bzrdir.open_workingtree()
1319
748
except errors.NoWorkingTree:
1320
source.bzrdir.create_workingtree(revision_id)
749
source.bzrdir.create_workingtree()
1321
750
return
1322
source.create_checkout(to_location, revision_id, lightweight,
1323
accelerator_tree, hardlink)
751
try:
752
os.mkdir(to_location)
753
except OSError, e:
754
if e.errno == errno.EEXIST:
755
raise BzrCommandError('Target directory "%s" already'
756
' exists.' % to_location)
757
if e.errno == errno.ENOENT:
758
raise BzrCommandError('Parent of "%s" does not exist.' %
759
to_location)
760
else:
761
raise
762
old_format = bzrdir.BzrDirFormat.get_default_format()
763
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
764
try:
765
if lightweight:
766
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
767
branch.BranchReferenceFormat().initialize(checkout, source)
768
else:
769
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
770
to_location, force_new_tree=False)
771
checkout = checkout_branch.bzrdir
772
checkout_branch.bind(source)
773
if revision_id is not None:
774
rh = checkout_branch.revision_history()
775
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
776
checkout.create_workingtree(revision_id)
777
finally:
778
bzrdir.BzrDirFormat.set_default_format(old_format)
1324
779
1325
780
1326
781
class cmd_renames(Command):
1329
784
# TODO: Option to show renames between two historical versions.
1330
785
1331
786
# TODO: Only show renames under dir, rather than in the whole branch.
1332
_see_also = ['status']
1333
787
takes_args = ['dir?']
1334
788
1335
789
@display_command
1336
790
def run(self, dir=u'.'):
791
from bzrlib.tree import find_renames
1337
792
tree = WorkingTree.open_containing(dir)[0]
1338
tree.lock_read()
1339
try:
1340
new_inv = tree.inventory
1341
old_tree = tree.basis_tree()
1342
old_tree.lock_read()
1343
try:
1344
old_inv = old_tree.inventory
1345
renames = []
1346
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1347
for f, paths, c, v, p, n, k, e in iterator:
1348
if paths[0] == paths[1]:
1349
continue
1350
if None in (paths):
1351
continue
1352
renames.append(paths)
1353
renames.sort()
1354
for old_name, new_name in renames:
1355
self.outf.write("%s => %s\n" % (old_name, new_name))
1356
finally:
1357
old_tree.unlock()
1358
finally:
1359
tree.unlock()
793
old_inv = tree.basis_tree().inventory
794
new_inv = tree.read_working_inventory()
795
renames = list(find_renames(old_inv, new_inv))
796
renames.sort()
797
for old_name, new_name in renames:
798
self.outf.write("%s => %s\n" % (old_name, new_name))
1360
799
1361
800
1362
801
class cmd_update(Command):
1363
802
"""Update a tree to have the latest code committed to its branch.
1364
803
1365
804
This will perform a merge into the working tree, and may generate
1366
conflicts. If you have any local changes, you will still
805
conflicts. If you have any local changes, you will still
1367
806
need to commit them after the update for the update to be complete.
1368
1369
If you want to discard your local changes, you can just do a
807
808
If you want to discard your local changes, you can just do a
1370
809
'bzr revert' instead of 'bzr commit' after the update.
1371
810
"""
1372
1373
_see_also = ['pull', 'working-trees', 'status-flags']
1374
811
takes_args = ['dir?']
1375
812
aliases = ['up']
1376
813
1377
814
def run(self, dir='.'):
1378
815
tree = WorkingTree.open_containing(dir)[0]
1379
possible_transports = []
1380
master = tree.branch.get_master_branch(
1381
possible_transports=possible_transports)
1382
if master is not None:
1383
tree.lock_write()
1384
else:
1385
tree.lock_tree_write()
816
tree.lock_write()
1386
817
try:
1387
existing_pending_merges = tree.get_parent_ids()[1:]
1388
last_rev = _mod_revision.ensure_null(tree.last_revision())
1389
if last_rev == _mod_revision.ensure_null(
1390
tree.branch.last_revision()):
818
last_rev = tree.last_revision()
819
if last_rev == tree.branch.last_revision():
1391
820
# may be up to date, check master too.
1392
if master is None or last_rev == _mod_revision.ensure_null(
1393
master.last_revision()):
821
master = tree.branch.get_master_branch()
822
if master is None or last_rev == master.last_revision():
1394
823
revno = tree.branch.revision_id_to_revno(last_rev)
1395
824
note("Tree is up to date at revision %d." % (revno,))
1396
825
return 0
1397
view_info = _get_view_info_for_change_reporter(tree)
1398
conflicts = tree.update(
1399
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1400
view_info=view_info), possible_transports=possible_transports)
1401
revno = tree.branch.revision_id_to_revno(
1402
_mod_revision.ensure_null(tree.last_revision()))
826
conflicts = tree.update()
827
revno = tree.branch.revision_id_to_revno(tree.last_revision())
1403
828
note('Updated to revision %d.' % (revno,))
1404
if tree.get_parent_ids()[1:] != existing_pending_merges:
1405
note('Your local commits will now show as pending merges with '
1406
"'bzr status', and can be committed with 'bzr commit'.")
1407
829
if conflicts != 0:
1408
830
return 1
1409
831
else:
1416
838
"""Show information about a working tree, branch or repository.
1417
839
1418
840
This command will show all known locations and formats associated to the
1419
tree, branch or repository.
1420
1421
In verbose mode, statistical information is included with each report.
1422
To see extended statistic information, use a verbosity level of 2 or
1423
higher by specifying the verbose option multiple times, e.g. -vv.
841
tree, branch or repository. Statistical information is included with
842
each report.
1424
843
1425
844
Branches and working trees will also report any missing revisions.
1426
1427
:Examples:
1428
1429
Display information on the format and related locations:
1430
1431
bzr info
1432
1433
Display the above together with extended format information and
1434
basic statistics (like the number of files in the working tree and
1435
number of revisions in the branch and repository):
1436
1437
bzr info -v
1438
1439
Display the above together with number of committers to the branch:
1440
1441
bzr info -vv
1442
845
"""
1443
_see_also = ['revno', 'working-trees', 'repositories']
1444
846
takes_args = ['location?']
1445
847
takes_options = ['verbose']
1446
encoding_type = 'replace'
1447
848
1448
849
@display_command
1449
850
def run(self, location=None, verbose=False):
1450
if verbose:
1451
noise_level = get_verbosity_level()
1452
else:
1453
noise_level = 0
1454
851
from bzrlib.info import show_bzrdir_info
1455
852
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
1456
verbose=noise_level, outfile=self.outf)
853
verbose=verbose)
1457
854
1458
855
1459
856
class cmd_remove(Command):
1460
"""Remove files or directories.
1461
1462
This makes bzr stop tracking changes to the specified files. bzr will delete
1463
them if they can easily be recovered using revert. If no options or
1464
parameters are given bzr will scan for files that are being tracked by bzr
1465
but missing in your tree and stop tracking them for you.
857
"""Make a file unversioned.
858
859
This makes bzr stop tracking changes to a versioned file. It does
860
not delete the working copy.
861
862
You can specify one or more files, and/or --new. If you specify --new,
863
only 'added' files will be removed. If you specify both, then new files
864
in the specified directories will be removed. If the directories are
865
also new, they will also be removed.
1466
866
"""
1467
867
takes_args = ['file*']
1468
takes_options = ['verbose',
1469
Option('new', help='Only remove files that have never been committed.'),
1470
RegistryOption.from_kwargs('file-deletion-strategy',
1471
'The file deletion mode to be used.',
1472
title='Deletion Strategy', value_switches=True, enum_switch=False,
1473
safe='Only delete files if they can be'
1474
' safely recovered (default).',
1475
keep="Don't delete any files.",
1476
force='Delete all the specified files, even if they can not be '
1477
'recovered and even if they are non-empty directories.')]
1478
aliases = ['rm', 'del']
868
takes_options = ['verbose', Option('new', help='remove newly-added files')]
869
aliases = ['rm']
1479
870
encoding_type = 'replace'
1480
1481
def run(self, file_list, verbose=False, new=False,
1482
file_deletion_strategy='safe'):
871
872
def run(self, file_list, verbose=False, new=False):
1483
873
tree, file_list = tree_files(file_list)
1484
1485
if file_list is not None:
1486
file_list = [f for f in file_list]
1487
1488
tree.lock_write()
1489
try:
1490
# Heuristics should probably all move into tree.remove_smart or
1491
# some such?
1492
if new:
1493
added = tree.changes_from(tree.basis_tree(),
1494
specific_files=file_list).added
1495
file_list = sorted([f[0] for f in added], reverse=True)
1496
if len(file_list) == 0:
1497
raise errors.BzrCommandError('No matching files.')
1498
elif file_list is None:
1499
# missing files show up in iter_changes(basis) as
1500
# versioned-with-no-kind.
1501
missing = []
1502
for change in tree.iter_changes(tree.basis_tree()):
1503
# Find paths in the working tree that have no kind:
1504
if change[1][1] is not None and change[6][1] is None:
1505
missing.append(change[1][1])
1506
file_list = sorted(missing, reverse=True)
1507
file_deletion_strategy = 'keep'
1508
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1509
keep_files=file_deletion_strategy=='keep',
1510
force=file_deletion_strategy=='force')
1511
finally:
1512
tree.unlock()
874
if new is False:
875
if file_list is None:
876
raise BzrCommandError('Specify one or more files to remove, or'
877
' use --new.')
878
else:
879
added = tree.changes_from(tree.basis_tree(),
880
specific_files=file_list).added
881
file_list = sorted([f[0] for f in added], reverse=True)
882
if len(file_list) == 0:
883
raise BzrCommandError('No matching files.')
884
tree.remove(file_list, verbose=verbose, to_file=self.outf)
1513
885
1514
886
1515
887
class cmd_file_id(Command):
1521
893
"""
1522
894
1523
895
hidden = True
1524
_see_also = ['inventory', 'ls']
1525
896
takes_args = ['filename']
1526
897
1527
898
@display_command
1528
899
def run(self, filename):
1529
900
tree, relpath = WorkingTree.open_containing(filename)
1530
i = tree.path2id(relpath)
1531
if i is None:
1532
raise errors.NotVersionedError(filename)
901
i = tree.inventory.path2id(relpath)
902
if i == None:
903
raise BzrError("%r is not a versioned file" % filename)
1533
904
else:
1534
905
self.outf.write(i + '\n')
1535
906
1547
918
@display_command
1548
919
def run(self, filename):
1549
920
tree, relpath = WorkingTree.open_containing(filename)
1550
fid = tree.path2id(relpath)
1551
if fid is None:
1552
raise errors.NotVersionedError(filename)
1553
segments = osutils.splitpath(relpath)
1554
for pos in range(1, len(segments) + 1):
1555
path = osutils.joinpath(segments[:pos])
1556
self.outf.write("%s\n" % tree.path2id(path))
921
inv = tree.inventory
922
fid = inv.path2id(relpath)
923
if fid == None:
924
raise BzrError("%r is not a versioned file" % filename)
925
for fip in inv.get_idpath(fid):
926
self.outf.write(fip + '\n')
1557
927
1558
928
1559
929
class cmd_reconcile(Command):
1561
931
1562
932
This can correct data mismatches that may have been caused by
1563
933
previous ghost operations or bzr upgrades. You should only
1564
need to run this command if 'bzr check' or a bzr developer
934
need to run this command if 'bzr check' or a bzr developer
1565
935
advises you to run it.
1566
936
1567
937
If a second branch is provided, cross-branch reconciliation is
1569
939
id which was not present in very early bzr versions is represented
1570
940
correctly in both branches.
1571
941
1572
At the same time it is run it may recompress data resulting in
942
At the same time it is run it may recompress data resulting in
1573
943
a potential saving in disk space or performance gain.
1574
944
1575
945
The branch *MUST* be on a listable system such as local disk or sftp.
1576
946
"""
1577
1578
_see_also = ['check']
1579
947
takes_args = ['branch?']
1580
948
1581
949
def run(self, branch="."):
1586
954
1587
955
class cmd_revision_history(Command):
1588
956
"""Display the list of revision ids on a branch."""
1589
1590
_see_also = ['log']
1591
957
takes_args = ['location?']
1592
958
1593
959
hidden = True
1602
968
1603
969
class cmd_ancestry(Command):
1604
970
"""List all revisions merged into this branch."""
1605
1606
_see_also = ['log', 'revision-history']
1607
971
takes_args = ['location?']
1608
972
1609
973
hidden = True
1620
984
last_revision = wt.last_revision()
1621
985
1622
986
revision_ids = b.repository.get_ancestry(last_revision)
987
assert revision_ids[0] == None
1623
988
revision_ids.pop(0)
1624
989
for revision_id in revision_ids:
1625
990
self.outf.write(revision_id + '\n')
1631
996
Use this to create an empty branch, or before importing an
1632
997
existing project.
1633
998
1634
If there is a repository in a parent directory of the location, then
999
If there is a repository in a parent directory of the location, then
1635
1000
the history of the branch will be stored in the repository. Otherwise
1636
init creates a standalone branch which carries its own history
1637
in the .bzr directory.
1001
init creates a standalone branch which carries its own history in
1002
.bzr.
1638
1003
1639
1004
If there is already a branch at the location but it has no working tree,
1640
1005
the tree can be populated with 'bzr checkout'.
1641
1006
1642
Recipe for importing a tree of files::
1643
1007
Recipe for importing a tree of files:
1644
1008
cd ~/project
1645
1009
bzr init
1646
1010
bzr add .
1647
1011
bzr status
1648
bzr commit -m "imported project"
1012
bzr commit -m 'imported project'
1649
1013
"""
1650
1651
_see_also = ['init-repository', 'branch', 'checkout']
1652
1014
takes_args = ['location?']
1653
1015
takes_options = [
1654
Option('create-prefix',
1655
help='Create the path leading up to the branch '
1656
'if it does not already exist.'),
1657
RegistryOption('format',
1658
help='Specify a format for this branch. '
1659
'See "help formats".',
1660
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1661
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1662
value_switches=True,
1663
title="Branch Format",
1664
),
1665
Option('append-revisions-only',
1666
help='Never change revnos or the existing log.'
1667
' Append revisions to it only.')
1668
]
1669
def run(self, location=None, format=None, append_revisions_only=False,
1670
create_prefix=False):
1016
Option('format',
1017
help='Specify a format for this branch. Current'
1018
' formats are: default, knit, metaweave and'
1019
' weave. Default is knit; metaweave and'
1020
' weave are deprecated',
1021
type=get_format_type),
1022
]
1023
def run(self, location=None, format=None):
1671
1024
if format is None:
1672
format = bzrdir.format_registry.make_bzrdir('default')
1025
format = get_format_type('default')
1673
1026
if location is None:
1674
1027
location = u'.'
1675
1028
1680
1033
# Just using os.mkdir, since I don't
1681
1034
# believe that we want to create a bunch of
1682
1035
# locations if the user supplies an extended path
1683
try:
1684
to_transport.ensure_base()
1685
except errors.NoSuchFile:
1686
if not create_prefix:
1687
raise errors.BzrCommandError("Parent directory of %s"
1688
" does not exist."
1689
"\nYou may supply --create-prefix to create all"
1690
" leading parent directories."
1691
% location)
1692
to_transport.create_prefix()
1693
1694
try:
1695
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
1696
except errors.NotBranchError:
1036
# TODO: create-prefix
1037
try:
1038
to_transport.mkdir('.')
1039
except errors.FileExists:
1040
pass
1041
1042
try:
1043
existing_bzrdir = bzrdir.BzrDir.open(location)
1044
except NotBranchError:
1697
1045
# really a NotBzrDir error...
1698
create_branch = bzrdir.BzrDir.create_branch_convenience
1699
branch = create_branch(to_transport.base, format=format,
1700
possible_transports=[to_transport])
1701
a_bzrdir = branch.bzrdir
1046
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1702
1047
else:
1703
from bzrlib.transport.local import LocalTransport
1704
if a_bzrdir.has_branch():
1048
if existing_bzrdir.has_branch():
1705
1049
if (isinstance(to_transport, LocalTransport)
1706
and not a_bzrdir.has_workingtree()):
1050
and not existing_bzrdir.has_workingtree()):
1707
1051
raise errors.BranchExistsWithoutWorkingTree(location)
1708
1052
raise errors.AlreadyBranchError(location)
1709
branch = a_bzrdir.create_branch()
1710
a_bzrdir.create_workingtree()
1711
if append_revisions_only:
1712
try:
1713
branch.set_append_revisions_only(True)
1714
except errors.UpgradeRequired:
1715
raise errors.BzrCommandError('This branch format cannot be set'
1716
' to append-revisions-only. Try --default.')
1717
if not is_quiet():
1718
from bzrlib.info import describe_layout, describe_format
1719
try:
1720
tree = a_bzrdir.open_workingtree(recommend_upgrade=False)
1721
except (errors.NoWorkingTree, errors.NotLocalUrl):
1722
tree = None
1723
repository = branch.repository
1724
layout = describe_layout(repository, branch, tree).lower()
1725
format = describe_format(a_bzrdir, repository, branch, tree)
1726
self.outf.write("Created a %s (format: %s)\n" % (layout, format))
1727
if repository.is_shared():
1728
#XXX: maybe this can be refactored into transport.path_or_url()
1729
url = repository.bzrdir.root_transport.external_url()
1730
try:
1731
url = urlutils.local_path_from_url(url)
1732
except errors.InvalidURL:
1733
pass
1734
self.outf.write("Using shared repository: %s\n" % url)
1053
else:
1054
existing_bzrdir.create_branch()
1055
existing_bzrdir.create_workingtree()
1735
1056
1736
1057
1737
1058
class cmd_init_repository(Command):
1738
1059
"""Create a shared repository to hold branches.
1739
1060
1740
New branches created under the repository directory will store their
1741
revisions in the repository, not in the branch directory.
1742
1743
If the --no-trees option is used then the branches in the repository
1744
will not have working trees by default.
1745
1746
:Examples:
1747
Create a shared repositories holding just branches::
1748
1749
bzr init-repo --no-trees repo
1750
bzr init repo/trunk
1751
1752
Make a lightweight checkout elsewhere::
1753
1754
bzr checkout --lightweight repo/trunk trunk-checkout
1755
cd trunk-checkout
1756
(add files here)
1061
New branches created under the repository directory will store their revisions
1062
in the repository, not in the branch directory, if the branch format supports
1063
shared storage.
1064
1065
example:
1066
bzr init-repo repo
1067
bzr init repo/trunk
1068
bzr checkout --lightweight repo/trunk trunk-checkout
1069
cd trunk-checkout
1070
(add files here)
1757
1071
"""
1758
1759
_see_also = ['init', 'branch', 'checkout', 'repositories']
1760
takes_args = ["location"]
1761
takes_options = [RegistryOption('format',
1762
help='Specify a format for this repository. See'
1763
' "bzr help formats" for details.',
1764
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1765
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1766
value_switches=True, title='Repository format'),
1767
Option('no-trees',
1768
help='Branches in the repository will default to'
1769
' not having a working tree.'),
1770
]
1072
takes_args = ["location"]
1073
takes_options = [Option('format',
1074
help='Specify a format for this repository.'
1075
' Current formats are: default, knit,'
1076
' metaweave and weave. Default is knit;'
1077
' metaweave and weave are deprecated',
1078
type=get_format_type),
1079
Option('trees',
1080
help='Allows branches in repository to have'
1081
' a working tree')]
1771
1082
aliases = ["init-repo"]
1772
1773
def run(self, location, format=None, no_trees=False):
1083
def run(self, location, format=None, trees=False):
1774
1084
if format is None:
1775
format = bzrdir.format_registry.make_bzrdir('default')
1085
format = get_format_type('default')
1776
1086
1777
1087
if location is None:
1778
1088
location = '.'
1779
1089
1780
1090
to_transport = transport.get_transport(location)
1781
to_transport.ensure_base()
1091
try:
1092
to_transport.mkdir('.')
1093
except errors.FileExists:
1094
pass
1782
1095
1783
1096
newdir = format.initialize_on_transport(to_transport)
1784
1097
repo = newdir.create_repository(shared=True)
1785
repo.set_make_working_trees(not no_trees)
1786
if not is_quiet():
1787
from bzrlib.info import show_bzrdir_info
1788
show_bzrdir_info(repo.bzrdir, verbose=0, outfile=self.outf)
1098
repo.set_make_working_trees(trees)
1789
1099
1790
1100
1791
1101
class cmd_diff(Command):
1792
"""Show differences in the working tree, between revisions or branches.
1793
1794
If no arguments are given, all changes for the current tree are listed.
1795
If files are given, only the changes in those files are listed.
1796
Remote and multiple branches can be compared by using the --old and
1797
--new options. If not provided, the default for both is derived from
1798
the first argument, if any, or the current tree if no arguments are
1799
given.
1102
"""Show differences in the working tree or between revisions.
1103
1104
If files are listed, only the changes in those files are listed.
1105
Otherwise, all changes for the tree are listed.
1800
1106
1801
1107
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1802
1108
produces patches suitable for "patch -p1".
1803
1109
1804
:Exit values:
1805
1 - changed
1806
2 - unrepresentable changes
1807
3 - error
1808
0 - no change
1809
1810
:Examples:
1811
Shows the difference in the working tree versus the last commit::
1812
1813
bzr diff
1814
1815
Difference between the working tree and revision 1::
1816
1817
bzr diff -r1
1818
1819
Difference between revision 2 and revision 1::
1820
1821
bzr diff -r1..2
1822
1823
Difference between revision 2 and revision 1 for branch xxx::
1824
1825
bzr diff -r1..2 xxx
1826
1827
Show just the differences for file NEWS::
1828
1829
bzr diff NEWS
1830
1831
Show the differences in working tree xxx for file NEWS::
1832
1833
bzr diff xxx/NEWS
1834
1835
Show the differences from branch xxx to this working tree:
1836
1837
bzr diff --old xxx
1838
1839
Show the differences between two branches for file NEWS::
1840
1841
bzr diff --old xxx --new yyy NEWS
1842
1843
Same as 'bzr diff' but prefix paths with old/ and new/::
1844
1845
bzr diff --prefix old/:new/
1110
examples:
1111
bzr diff
1112
Shows the difference in the working tree versus the last commit
1113
bzr diff -r1
1114
Difference between the working tree and revision 1
1115
bzr diff -r1..2
1116
Difference between revision 2 and revision 1
1117
bzr diff --diff-prefix old/:new/
1118
Same as 'bzr diff' but prefix paths with old/ and new/
1119
bzr diff bzr.mine bzr.dev
1120
Show the differences between the two working trees
1121
bzr diff foo.c
1122
Show just the differences for 'foo.c'
1846
1123
"""
1847
_see_also = ['status']
1124
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1125
# or a graphical diff.
1126
1127
# TODO: Python difflib is not exactly the same as unidiff; should
1128
# either fix it up or prefer to use an external diff.
1129
1130
# TODO: Selected-file diff is inefficient and doesn't show you
1131
# deleted files.
1132
1133
# TODO: This probably handles non-Unix newlines poorly.
1134
1848
1135
takes_args = ['file*']
1849
takes_options = [
1850
Option('diff-options', type=str,
1851
help='Pass these options to the external diff program.'),
1852
Option('prefix', type=str,
1853
short_name='p',
1854
help='Set prefixes added to old and new filenames, as '
1855
'two values separated by a colon. (eg "old/:new/").'),
1856
Option('old',
1857
help='Branch/tree to compare from.',
1858
type=unicode,
1859
),
1860
Option('new',
1861
help='Branch/tree to compare to.',
1862
type=unicode,
1863
),
1864
'revision',
1865
'change',
1866
Option('using',
1867
help='Use this command to compare files.',
1868
type=unicode,
1869
),
1870
]
1136
takes_options = ['revision', 'diff-options', 'prefix']
1871
1137
aliases = ['di', 'dif']
1872
1138
encoding_type = 'exact'
1873
1139
1874
1140
@display_command
1875
1141
def run(self, revision=None, file_list=None, diff_options=None,
1876
prefix=None, old=None, new=None, using=None):
1877
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
1142
prefix=None):
1143
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1878
1144
1879
1145
if (prefix is None) or (prefix == '0'):
1880
1146
# diff -p0 format
1883
1149
elif prefix == '1':
1884
1150
old_label = 'old/'
1885
1151
new_label = 'new/'
1886
elif ':' in prefix:
1152
else:
1153
if not ':' in prefix:
1154
raise BzrError("--diff-prefix expects two values separated by a colon")
1887
1155
old_label, new_label = prefix.split(":")
1156
1157
try:
1158
tree1, file_list = internal_tree_files(file_list)
1159
tree2 = None
1160
b = None
1161
b2 = None
1162
except FileInWrongBranch:
1163
if len(file_list) != 2:
1164
raise BzrCommandError("Files are in different branches")
1165
1166
tree1, file1 = WorkingTree.open_containing(file_list[0])
1167
tree2, file2 = WorkingTree.open_containing(file_list[1])
1168
if file1 != "" or file2 != "":
1169
# FIXME diff those two files. rbc 20051123
1170
raise BzrCommandError("Files are in different branches")
1171
file_list = None
1172
except NotBranchError:
1173
if (revision is not None and len(revision) == 2
1174
and not revision[0].needs_branch()
1175
and not revision[1].needs_branch()):
1176
# If both revision specs include a branch, we can
1177
# diff them without needing a local working tree
1178
tree1, tree2 = None, None
1179
else:
1180
raise
1181
if revision is not None:
1182
if tree2 is not None:
1183
raise BzrCommandError("Can't specify -r with two branches")
1184
if (len(revision) == 1) or (revision[1].spec is None):
1185
return diff_cmd_helper(tree1, file_list, diff_options,
1186
revision[0],
1187
old_label=old_label, new_label=new_label)
1188
elif len(revision) == 2:
1189
return diff_cmd_helper(tree1, file_list, diff_options,
1190
revision[0], revision[1],
1191
old_label=old_label, new_label=new_label)
1192
else:
1193
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1888
1194
else:
1889
raise errors.BzrCommandError(
1890
'--prefix expects two values separated by a colon'
1891
' (eg "old/:new/")')
1892
1893
if revision and len(revision) > 2:
1894
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1895
' one or two revision specifiers')
1896
1897
old_tree, new_tree, specific_files, extra_trees = \
1898
_get_trees_to_diff(file_list, revision, old, new,
1899
apply_view=True)
1900
return show_diff_trees(old_tree, new_tree, sys.stdout,
1901
specific_files=specific_files,
1902
external_diff_options=diff_options,
1903
old_label=old_label, new_label=new_label,
1904
extra_trees=extra_trees, using=using)
1195
if tree2 is not None:
1196
return show_diff_trees(tree1, tree2, sys.stdout,
1197
specific_files=file_list,
1198
external_diff_options=diff_options,
1199
old_label=old_label, new_label=new_label)
1200
else:
1201
return diff_cmd_helper(tree1, file_list, diff_options,
1202
old_label=old_label, new_label=new_label)
1905
1203
1906
1204
1907
1205
class cmd_deleted(Command):
1913
1211
# directories with readdir, rather than stating each one. Same
1914
1212
# level of effort but possibly much less IO. (Or possibly not,
1915
1213
# if the directories are very large...)
1916
_see_also = ['status', 'ls']
1917
1214
takes_options = ['show-ids']
1918
1215
1919
1216
@display_command
1920
1217
def run(self, show_ids=False):
1921
1218
tree = WorkingTree.open_containing(u'.')[0]
1922
tree.lock_read()
1923
try:
1924
old = tree.basis_tree()
1925
old.lock_read()
1926
try:
1927
for path, ie in old.inventory.iter_entries():
1928
if not tree.has_id(ie.file_id):
1929
self.outf.write(path)
1930
if show_ids:
1931
self.outf.write(' ')
1932
self.outf.write(ie.file_id)
1933
self.outf.write('\n')
1934
finally:
1935
old.unlock()
1936
finally:
1937
tree.unlock()
1219
old = tree.basis_tree()
1220
for path, ie in old.inventory.iter_entries():
1221
if not tree.has_id(ie.file_id):
1222
self.outf.write(path)
1223
if show_ids:
1224
self.outf.write(' ')
1225
self.outf.write(ie.file_id)
1226
self.outf.write('\n')
1938
1227
1939
1228
1940
1229
class cmd_modified(Command):
1941
"""List files modified in working tree.
1942
"""
1943
1230
"""List files modified in working tree."""
1944
1231
hidden = True
1945
_see_also = ['status', 'ls']
1946
takes_options = [
1947
Option('null',
1948
help='Write an ascii NUL (\\0) separator '
1949
'between files rather than a newline.')
1950
]
1951
1952
1232
@display_command
1953
def run(self, null=False):
1233
def run(self):
1954
1234
tree = WorkingTree.open_containing(u'.')[0]
1955
1235
td = tree.changes_from(tree.basis_tree())
1956
1236
for path, id, kind, text_modified, meta_modified in td.modified:
1957
if null:
1958
self.outf.write(path + '\0')
1959
else:
1960
self.outf.write(osutils.quotefn(path) + '\n')
1237
self.outf.write(path + '\n')
1961
1238
1962
1239
1963
1240
class cmd_added(Command):
1964
"""List files added in working tree.
1965
"""
1966
1241
"""List files added in working tree."""
1967
1242
hidden = True
1968
_see_also = ['status', 'ls']
1969
takes_options = [
1970
Option('null',
1971
help='Write an ascii NUL (\\0) separator '
1972
'between files rather than a newline.')
1973
]
1974
1975
1243
@display_command
1976
def run(self, null=False):
1244
def run(self):
1977
1245
wt = WorkingTree.open_containing(u'.')[0]
1978
wt.lock_read()
1979
try:
1980
basis = wt.basis_tree()
1981
basis.lock_read()
1982
try:
1983
basis_inv = basis.inventory
1984
inv = wt.inventory
1985
for file_id in inv:
1986
if file_id in basis_inv:
1987
continue
1988
if inv.is_root(file_id) and len(basis_inv) == 0:
1989
continue
1990
path = inv.id2path(file_id)
1991
if not os.access(osutils.abspath(path), os.F_OK):
1992
continue
1993
if null:
1994
self.outf.write(path + '\0')
1995
else:
1996
self.outf.write(osutils.quotefn(path) + '\n')
1997
finally:
1998
basis.unlock()
1999
finally:
2000
wt.unlock()
1246
basis_inv = wt.basis_tree().inventory
1247
inv = wt.inventory
1248
for file_id in inv:
1249
if file_id in basis_inv:
1250
continue
1251
path = inv.id2path(file_id)
1252
if not os.access(osutils.abspath(path), os.F_OK):
1253
continue
1254
self.outf.write(path + '\n')
2001
1255
2002
1256
2003
1257
class cmd_root(Command):
2005
1259
2006
1260
The root is the nearest enclosing directory with a .bzr control
2007
1261
directory."""
2008
2009
1262
takes_args = ['filename?']
2010
1263
@display_command
2011
1264
def run(self, filename=None):
2014
1267
self.outf.write(tree.basedir + '\n')
2015
1268
2016
1269
2017
def _parse_limit(limitstring):
2018
try:
2019
return int(limitstring)
2020
except ValueError:
2021
msg = "The limit argument must be an integer."
2022
raise errors.BzrCommandError(msg)
2023
2024
2025
def _parse_levels(s):
2026
try:
2027
return int(s)
2028
except ValueError:
2029
msg = "The levels argument must be an integer."
2030
raise errors.BzrCommandError(msg)
2031
2032
2033
1270
class cmd_log(Command):
2034
"""Show historical log for a branch or subset of a branch.
2035
2036
log is bzr's default tool for exploring the history of a branch.
2037
The branch to use is taken from the first parameter. If no parameters
2038
are given, the branch containing the working directory is logged.
2039
Here are some simple examples::
2040
2041
bzr log log the current branch
2042
bzr log foo.py log a file in its branch
2043
bzr log http://server/branch log a branch on a server
2044
2045
The filtering, ordering and information shown for each revision can
2046
be controlled as explained below. By default, all revisions are
2047
shown sorted (topologically) so that newer revisions appear before
2048
older ones and descendants always appear before ancestors. If displayed,
2049
merged revisions are shown indented under the revision in which they
2050
were merged.
2051
2052
:Output control:
2053
2054
The log format controls how information about each revision is
2055
displayed. The standard log formats are called ``long``, ``short``
2056
and ``line``. The default is long. See ``bzr help log-formats``
2057
for more details on log formats.
2058
2059
The following options can be used to control what information is
2060
displayed::
2061
2062
-l N display a maximum of N revisions
2063
-n N display N levels of revisions (0 for all, 1 for collapsed)
2064
-v display a status summary (delta) for each revision
2065
-p display a diff (patch) for each revision
2066
--show-ids display revision-ids (and file-ids), not just revnos
2067
2068
Note that the default number of levels to display is a function of the
2069
log format. If the -n option is not used, the standard log formats show
2070
just the top level (mainline).
2071
2072
Status summaries are shown using status flags like A, M, etc. To see
2073
the changes explained using words like ``added`` and ``modified``
2074
instead, use the -vv option.
2075
2076
:Ordering control:
2077
2078
To display revisions from oldest to newest, use the --forward option.
2079
In most cases, using this option will have little impact on the total
2080
time taken to produce a log, though --forward does not incrementally
2081
display revisions like --reverse does when it can.
2082
2083
:Revision filtering:
2084
2085
The -r option can be used to specify what revision or range of revisions
2086
to filter against. The various forms are shown below::
2087
2088
-rX display revision X
2089
-rX.. display revision X and later
2090
-r..Y display up to and including revision Y
2091
-rX..Y display from X to Y inclusive
2092
2093
See ``bzr help revisionspec`` for details on how to specify X and Y.
2094
Some common examples are given below::
2095
2096
-r-1 show just the tip
2097
-r-10.. show the last 10 mainline revisions
2098
-rsubmit:.. show what's new on this branch
2099
-rancestor:path.. show changes since the common ancestor of this
2100
branch and the one at location path
2101
-rdate:yesterday.. show changes since yesterday
2102
2103
When logging a range of revisions using -rX..Y, log starts at
2104
revision Y and searches back in history through the primary
2105
("left-hand") parents until it finds X. When logging just the
2106
top level (using -n1), an error is reported if X is not found
2107
along the way. If multi-level logging is used (-n0), X may be
2108
a nested merge revision and the log will be truncated accordingly.
2109
2110
:Path filtering:
2111
2112
If parameters are given and the first one is not a branch, the log
2113
will be filtered to show only those revisions that changed the
2114
nominated files or directories.
2115
2116
Filenames are interpreted within their historical context. To log a
2117
deleted file, specify a revision range so that the file existed at
2118
the end or start of the range.
2119
2120
Historical context is also important when interpreting pathnames of
2121
renamed files/directories. Consider the following example:
2122
2123
* revision 1: add tutorial.txt
2124
* revision 2: modify tutorial.txt
2125
* revision 3: rename tutorial.txt to guide.txt; add tutorial.txt
2126
2127
In this case:
2128
2129
* ``bzr log guide.txt`` will log the file added in revision 1
2130
2131
* ``bzr log tutorial.txt`` will log the new file added in revision 3
2132
2133
* ``bzr log -r2 -p tutorial.txt`` will show the changes made to
2134
the original file in revision 2.
2135
2136
* ``bzr log -r2 -p guide.txt`` will display an error message as there
2137
was no file called guide.txt in revision 2.
2138
2139
Renames are always followed by log. By design, there is no need to
2140
explicitly ask for this (and no way to stop logging a file back
2141
until it was last renamed).
2142
2143
:Other filtering:
2144
2145
The --message option can be used for finding revisions that match a
2146
regular expression in a commit message.
2147
2148
:Tips & tricks:
2149
2150
GUI tools and IDEs are often better at exploring history than command
2151
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2152
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2153
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2154
2155
Web interfaces are often better at exploring history than command line
2156
tools, particularly for branches on servers. You may prefer Loggerhead
2157
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2158
2159
You may find it useful to add the aliases below to ``bazaar.conf``::
2160
2161
[ALIASES]
2162
tip = log -r-1
2163
top = log -l10 --line
2164
show = log -v -p
2165
2166
``bzr tip`` will then show the latest revision while ``bzr top``
2167
will show the last 10 mainline revisions. To see the details of a
2168
particular revision X, ``bzr show -rX``.
2169
2170
If you are interested in looking deeper into a particular merge X,
2171
use ``bzr log -n0 -rX``.
2172
2173
``bzr log -v`` on a branch with lots of history is currently
2174
very slow. A fix for this issue is currently under development.
2175
With or without that fix, it is recommended that a revision range
2176
be given when using the -v option.
2177
2178
bzr has a generic full-text matching plugin, bzr-search, that can be
2179
used to find revisions matching user names, commit messages, etc.
2180
Among other features, this plugin can find all revisions containing
2181
a list of words but not others.
2182
2183
When exploring non-mainline history on large projects with deep
2184
history, the performance of log can be greatly improved by installing
2185
the historycache plugin. This plugin buffers historical information
2186
trading disk space for faster speed.
1271
"""Show log of a branch, file, or directory.
1272
1273
By default show the log of the branch containing the working directory.
1274
1275
To request a range of logs, you can use the command -r begin..end
1276
-r revision requests a specific revision, -r ..end or -r begin.. are
1277
also valid.
1278
1279
examples:
1280
bzr log
1281
bzr log foo.c
1282
bzr log -r -10.. http://server/branch
2187
1283
"""
2188
takes_args = ['file*']
2189
_see_also = ['log-formats', 'revisionspec']
2190
takes_options = [
2191
Option('forward',
2192
help='Show from oldest to newest.'),
2193
'timezone',
2194
custom_help('verbose',
2195
help='Show files changed in each revision.'),
2196
'show-ids',
2197
'revision',
2198
Option('change',
2199
type=bzrlib.option._parse_revision_str,
2200
short_name='c',
2201
help='Show just the specified revision.'
2202
' See also "help revisionspec".'),
2203
'log-format',
2204
Option('levels',
2205
short_name='n',
2206
help='Number of levels to display - 0 for all, 1 for flat.',
2207
argname='N',
2208
type=_parse_levels),
2209
Option('message',
2210
short_name='m',
2211
help='Show revisions whose message matches this '
2212
'regular expression.',
2213
type=str),
2214
Option('limit',
2215
short_name='l',
2216
help='Limit the output to the first N revisions.',
2217
argname='N',
2218
type=_parse_limit),
2219
Option('show-diff',
2220
short_name='p',
2221
help='Show changes made in each revision as a patch.'),
2222
Option('include-merges',
2223
help='Show merged revisions like --levels 0 does.'),
2224
]
1284
1285
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1286
1287
takes_args = ['location?']
1288
takes_options = [Option('forward',
1289
help='show from oldest to newest'),
1290
'timezone',
1291
Option('verbose',
1292
help='show files changed in each revision'),
1293
'show-ids', 'revision',
1294
'log-format',
1295
'line', 'long',
1296
Option('message',
1297
help='show revisions whose message matches this regexp',
1298
type=str),
1299
'short',
1300
]
2225
1301
encoding_type = 'replace'
2226
1302
2227
1303
@display_command
2228
def run(self, file_list=None, timezone='original',
1304
def run(self, location=None, timezone='original',
2229
1305
verbose=False,
2230
1306
show_ids=False,
2231
1307
forward=False,
2232
1308
revision=None,
2233
change=None,
2234
1309
log_format=None,
2235
levels=None,
2236
1310
message=None,
2237
limit=None,
2238
show_diff=False,
2239
include_merges=False):
2240
from bzrlib.log import (
2241
Logger,
2242
make_log_request_dict,
2243
_get_info_for_log_files,
2244
)
1311
long=False,
1312
short=False,
1313
line=False):
1314
from bzrlib.log import log_formatter, show_log
1315
assert message is None or isinstance(message, basestring), \
1316
"invalid message argument %r" % message
2245
1317
direction = (forward and 'forward') or 'reverse'
2246
if include_merges:
2247
if levels is None:
2248
levels = 0
2249
else:
2250
raise errors.BzrCommandError(
2251
'--levels and --include-merges are mutually exclusive')
2252
2253
if change is not None:
2254
if len(change) > 1:
2255
raise errors.RangeInChangeOption()
2256
if revision is not None:
2257
raise errors.BzrCommandError(
2258
'--revision and --change are mutually exclusive')
2259
else:
2260
revision = change
2261
2262
file_ids = []
2263
filter_by_dir = False
2264
if file_list:
2265
# find the file ids to log and check for directory filtering
2266
b, file_info_list, rev1, rev2 = _get_info_for_log_files(revision,
2267
file_list)
2268
for relpath, file_id, kind in file_info_list:
2269
if file_id is None:
2270
raise errors.BzrCommandError(
2271
"Path unknown at end or start of revision range: %s" %
2272
relpath)
2273
# If the relpath is the top of the tree, we log everything
2274
if relpath == '':
2275
file_ids = []
2276
break
2277
else:
2278
file_ids.append(file_id)
2279
filter_by_dir = filter_by_dir or (
2280
kind in ['directory', 'tree-reference'])
2281
else:
2282
# log everything
2283
# FIXME ? log the current subdir only RBC 20060203
2284
if revision is not None \
2285
and len(revision) > 0 and revision[0].get_branch():
2286
location = revision[0].get_branch()
2287
else:
2288
location = '.'
2289
dir, relpath = bzrdir.BzrDir.open_containing(location)
2290
b = dir.open_branch()
2291
rev1, rev2 = _get_revision_range(revision, b, self.name())
2292
2293
# Decide on the type of delta & diff filtering to use
2294
# TODO: add an --all-files option to make this configurable & consistent
2295
if not verbose:
2296
delta_type = None
2297
else:
2298
delta_type = 'full'
2299
if not show_diff:
2300
diff_type = None
2301
elif file_ids:
2302
diff_type = 'partial'
2303
else:
2304
diff_type = 'full'
2305
2306
b.lock_read()
2307
try:
2308
# Build the log formatter
2309
if log_format is None:
2310
log_format = log.log_formatter_registry.get_default(b)
2311
lf = log_format(show_ids=show_ids, to_file=self.outf,
2312
show_timezone=timezone,
2313
delta_format=get_verbosity_level(),
2314
levels=levels,
2315
show_advice=levels is None)
2316
2317
# Choose the algorithm for doing the logging. It's annoying
2318
# having multiple code paths like this but necessary until
2319
# the underlying repository format is faster at generating
2320
# deltas or can provide everything we need from the indices.
2321
# The default algorithm - match-using-deltas - works for
2322
# multiple files and directories and is faster for small
2323
# amounts of history (200 revisions say). However, it's too
2324
# slow for logging a single file in a repository with deep
2325
# history, i.e. > 10K revisions. In the spirit of "do no
2326
# evil when adding features", we continue to use the
2327
# original algorithm - per-file-graph - for the "single
2328
# file that isn't a directory without showing a delta" case.
2329
partial_history = revision and b.repository._format.supports_chks
2330
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2331
or delta_type or partial_history)
2332
2333
# Build the LogRequest and execute it
2334
if len(file_ids) == 0:
2335
file_ids = None
2336
rqst = make_log_request_dict(
2337
direction=direction, specific_fileids=file_ids,
2338
start_revision=rev1, end_revision=rev2, limit=limit,
2339
message_search=message, delta_type=delta_type,
2340
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2341
Logger(b, rqst).show(lf)
2342
finally:
2343
b.unlock()
2344
2345
2346
def _get_revision_range(revisionspec_list, branch, command_name):
2347
"""Take the input of a revision option and turn it into a revision range.
2348
2349
It returns RevisionInfo objects which can be used to obtain the rev_id's
2350
of the desired revisions. It does some user input validations.
2351
"""
2352
if revisionspec_list is None:
2353
rev1 = None
2354
rev2 = None
2355
elif len(revisionspec_list) == 1:
2356
rev1 = rev2 = revisionspec_list[0].in_history(branch)
2357
elif len(revisionspec_list) == 2:
2358
start_spec = revisionspec_list[0]
2359
end_spec = revisionspec_list[1]
2360
if end_spec.get_branch() != start_spec.get_branch():
2361
# b is taken from revision[0].get_branch(), and
2362
# show_log will use its revision_history. Having
2363
# different branches will lead to weird behaviors.
2364
raise errors.BzrCommandError(
2365
"bzr %s doesn't accept two revisions in different"
2366
" branches." % command_name)
2367
rev1 = start_spec.in_history(branch)
2368
# Avoid loading all of history when we know a missing
2369
# end of range means the last revision ...
2370
if end_spec.spec is None:
2371
last_revno, last_revision_id = branch.last_revision_info()
2372
rev2 = RevisionInfo(branch, last_revno, last_revision_id)
2373
else:
2374
rev2 = end_spec.in_history(branch)
2375
else:
2376
raise errors.BzrCommandError(
2377
'bzr %s --revision takes one or two values.' % command_name)
2378
return rev1, rev2
2379
2380
2381
def _revision_range_to_revid_range(revision_range):
2382
rev_id1 = None
2383
rev_id2 = None
2384
if revision_range[0] is not None:
2385
rev_id1 = revision_range[0].rev_id
2386
if revision_range[1] is not None:
2387
rev_id2 = revision_range[1].rev_id
2388
return rev_id1, rev_id2
1318
1319
# log everything
1320
file_id = None
1321
if location:
1322
# find the file id to log:
1323
1324
dir, fp = bzrdir.BzrDir.open_containing(location)
1325
b = dir.open_branch()
1326
if fp != '':
1327
try:
1328
# might be a tree:
1329
inv = dir.open_workingtree().inventory
1330
except (errors.NotBranchError, errors.NotLocalUrl):
1331
# either no tree, or is remote.
1332
inv = b.basis_tree().inventory
1333
file_id = inv.path2id(fp)
1334
else:
1335
# local dir only
1336
# FIXME ? log the current subdir only RBC 20060203
1337
dir, relpath = bzrdir.BzrDir.open_containing('.')
1338
b = dir.open_branch()
1339
1340
if revision is None:
1341
rev1 = None
1342
rev2 = None
1343
elif len(revision) == 1:
1344
rev1 = rev2 = revision[0].in_history(b).revno
1345
elif len(revision) == 2:
1346
if revision[0].spec is None:
1347
# missing begin-range means first revision
1348
rev1 = 1
1349
else:
1350
rev1 = revision[0].in_history(b).revno
1351
1352
if revision[1].spec is None:
1353
# missing end-range means last known revision
1354
rev2 = b.revno()
1355
else:
1356
rev2 = revision[1].in_history(b).revno
1357
else:
1358
raise BzrCommandError('bzr log --revision takes one or two values.')
1359
1360
# By this point, the revision numbers are converted to the +ve
1361
# form if they were supplied in the -ve form, so we can do
1362
# this comparison in relative safety
1363
if rev1 > rev2:
1364
(rev2, rev1) = (rev1, rev2)
1365
1366
if (log_format == None):
1367
default = b.get_config().log_format()
1368
log_format = get_log_format(long=long, short=short, line=line,
1369
default=default)
1370
lf = log_formatter(log_format,
1371
show_ids=show_ids,
1372
to_file=self.outf,
1373
show_timezone=timezone)
1374
1375
show_log(b,
1376
lf,
1377
file_id,
1378
verbose=verbose,
1379
direction=direction,
1380
start_revision=rev1,
1381
end_revision=rev2,
1382
search=message)
1383
2389
1384
2390
1385
def get_log_format(long=False, short=False, line=False, default='long'):
2391
1386
log_format = default
2411
1406
def run(self, filename):
2412
1407
tree, relpath = WorkingTree.open_containing(filename)
2413
1408
b = tree.branch
2414
file_id = tree.path2id(relpath)
1409
inv = tree.read_working_inventory()
1410
file_id = inv.path2id(relpath)
2415
1411
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
2416
1412
self.outf.write("%6d %s\n" % (revno, what))
2417
1413
2419
1415
class cmd_ls(Command):
2420
1416
"""List files in a tree.
2421
1417
"""
1418
# TODO: Take a revision or remote path and list that tree instead.
1419
hidden = True
1420
takes_options = ['verbose', 'revision',
1421
Option('non-recursive',
1422
help='don\'t recurse into sub-directories'),
1423
Option('from-root',
1424
help='Print all paths from the root of the branch.'),
1425
Option('unknown', help='Print unknown files'),
1426
Option('versioned', help='Print versioned files'),
1427
Option('ignored', help='Print ignored files'),
2422
1428
2423
_see_also = ['status', 'cat']
2424
takes_args = ['path?']
2425
takes_options = [
2426
'verbose',
2427
'revision',
2428
Option('recursive', short_name='R',
2429
help='Recurse into subdirectories.'),
2430
Option('from-root',
2431
help='Print paths relative to the root of the branch.'),
2432
Option('unknown', help='Print unknown files.'),
2433
Option('versioned', help='Print versioned files.',
2434
short_name='V'),
2435
Option('ignored', help='Print ignored files.'),
2436
Option('null',
2437
help='Write an ascii NUL (\\0) separator '
2438
'between files rather than a newline.'),
2439
Option('kind',
2440
help='List entries of a particular kind: file, directory, symlink.',
2441
type=unicode),
2442
'show-ids',
2443
]
1429
Option('null', help='Null separate the files'),
1430
]
2444
1431
@display_command
2445
def run(self, revision=None, verbose=False,
2446
recursive=False, from_root=False,
1432
def run(self, revision=None, verbose=False,
1433
non_recursive=False, from_root=False,
2447
1434
unknown=False, versioned=False, ignored=False,
2448
null=False, kind=None, show_ids=False, path=None):
2449
2450
if kind and kind not in ('file', 'directory', 'symlink'):
2451
raise errors.BzrCommandError('invalid kind specified')
1435
null=False):
2452
1436
2453
1437
if verbose and null:
2454
raise errors.BzrCommandError('Cannot set both --verbose and --null')
1438
raise BzrCommandError('Cannot set both --verbose and --null')
2455
1439
all = not (unknown or versioned or ignored)
2456
1440
2457
1441
selection = {'I':ignored, '?':unknown, 'V':versioned}
2458
1442
2459
if path is None:
2460
fs_path = '.'
2461
else:
2462
if from_root:
2463
raise errors.BzrCommandError('cannot specify both --from-root'
2464
' and PATH')
2465
fs_path = path
2466
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2467
fs_path)
2468
2469
# Calculate the prefix to use
2470
prefix = None
1443
tree, relpath = WorkingTree.open_containing(u'.')
2471
1444
if from_root:
2472
if relpath:
2473
prefix = relpath + '/'
2474
elif fs_path != '.':
2475
prefix = fs_path + '/'
2476
2477
if revision is not None or tree is None:
2478
tree = _get_one_revision_tree('ls', revision, branch=branch)
2479
2480
apply_view = False
2481
if isinstance(tree, WorkingTree) and tree.supports_views():
2482
view_files = tree.views.lookup_view()
2483
if view_files:
2484
apply_view = True
2485
view_str = views.view_display_str(view_files)
2486
note("Ignoring files outside view. View is %s" % view_str)
2487
2488
tree.lock_read()
2489
try:
2490
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2491
from_dir=relpath, recursive=recursive):
2492
# Apply additional masking
1445
relpath = u''
1446
elif relpath:
1447
relpath += '/'
1448
if revision is not None:
1449
tree = tree.branch.repository.revision_tree(
1450
revision[0].in_history(tree.branch).rev_id)
1451
1452
for fp, fc, kind, fid, entry in tree.list_files():
1453
if fp.startswith(relpath):
1454
fp = fp[len(relpath):]
1455
if non_recursive and '/' in fp:
1456
continue
2493
1457
if not all and not selection[fc]:
2494
1458
continue
2495
if kind is not None and fkind != kind:
2496
continue
2497
if apply_view:
2498
try:
2499
if relpath:
2500
fullpath = osutils.pathjoin(relpath, fp)
2501
else:
2502
fullpath = fp
2503
views.check_path_in_view(tree, fullpath)
2504
except errors.FileOutsideView:
2505
continue
2506
2507
# Output the entry
2508
if prefix:
2509
fp = osutils.pathjoin(prefix, fp)
2510
kindch = entry.kind_character()
2511
outstring = fp + kindch
2512
ui.ui_factory.clear_term()
2513
1459
if verbose:
2514
outstring = '%-8s %s' % (fc, outstring)
2515
if show_ids and fid is not None:
2516
outstring = "%-50s %s" % (outstring, fid)
2517
self.outf.write(outstring + '\n')
1460
kindch = entry.kind_character()
1461
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
2518
1462
elif null:
2519
1463
self.outf.write(fp + '\0')
2520
if show_ids:
2521
if fid is not None:
2522
self.outf.write(fid)
2523
self.outf.write('\0')
2524
1464
self.outf.flush()
2525
1465
else:
2526
if show_ids:
2527
if fid is not None:
2528
my_id = fid
2529
else:
2530
my_id = ''
2531
self.outf.write('%-50s %s\n' % (outstring, my_id))
2532
else:
2533
self.outf.write(outstring + '\n')
2534
finally:
2535
tree.unlock()
1466
self.outf.write(fp + '\n')
2536
1467
2537
1468
2538
1469
class cmd_unknowns(Command):
2539
"""List unknown files.
2540
"""
2541
2542
hidden = True
2543
_see_also = ['ls']
2544
1470
"""List unknown files."""
2545
1471
@display_command
2546
1472
def run(self):
2547
1473
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2549
1475
2550
1476
2551
1477
class cmd_ignore(Command):
2552
"""Ignore specified files or patterns.
2553
2554
See ``bzr help patterns`` for details on the syntax of patterns.
1478
"""Ignore a command or pattern.
2555
1479
2556
1480
To remove patterns from the ignore list, edit the .bzrignore file.
2557
After adding, editing or deleting that file either indirectly by
2558
using this command or directly by using an editor, be sure to commit
2559
it.
2560
2561
Note: ignore patterns containing shell wildcards must be quoted from
2562
the shell on Unix.
2563
2564
:Examples:
2565
Ignore the top level Makefile::
2566
2567
bzr ignore ./Makefile
2568
2569
Ignore class files in all directories::
2570
2571
bzr ignore "*.class"
2572
2573
Ignore .o files under the lib directory::
2574
2575
bzr ignore "lib/**/*.o"
2576
2577
Ignore .o files under the lib directory::
2578
2579
bzr ignore "RE:lib/.*\.o"
2580
2581
Ignore everything but the "debian" toplevel directory::
2582
2583
bzr ignore "RE:(?!debian/).*"
1481
1482
If the pattern contains a slash, it is compared to the whole path
1483
from the branch root. Otherwise, it is compared to only the last
1484
component of the path. To match a file only in the root directory,
1485
prepend './'.
1486
1487
Ignore patterns are case-insensitive on case-insensitive systems.
1488
1489
Note: wildcards must be quoted from the shell on Unix.
1490
1491
examples:
1492
bzr ignore ./Makefile
1493
bzr ignore '*.class'
2584
1494
"""
2585
2586
_see_also = ['status', 'ignored', 'patterns']
2587
takes_args = ['name_pattern*']
1495
# TODO: Complain if the filename is absolute
1496
takes_args = ['name_pattern?']
2588
1497
takes_options = [
2589
Option('old-default-rules',
2590
help='Write out the ignore rules bzr < 0.9 always used.')
2591
]
2592
2593
def run(self, name_pattern_list=None, old_default_rules=None):
2594
from bzrlib import ignores
1498
Option('old-default-rules',
1499
help='Out the ignore rules bzr < 0.9 always used.')
1500
]
1501
1502
def run(self, name_pattern=None, old_default_rules=None):
1503
from bzrlib.atomicfile import AtomicFile
2595
1504
if old_default_rules is not None:
2596
1505
# dump the rules and exit
2597
1506
for pattern in ignores.OLD_DEFAULTS:
2598
1507
print pattern
2599
1508
return
2600
if not name_pattern_list:
2601
raise errors.BzrCommandError("ignore requires at least one "
2602
"NAME_PATTERN or --old-default-rules")
2603
name_pattern_list = [globbing.normalize_pattern(p)
2604
for p in name_pattern_list]
2605
for name_pattern in name_pattern_list:
2606
if (name_pattern[0] == '/' or
2607
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2608
raise errors.BzrCommandError(
2609
"NAME_PATTERN should not be an absolute path")
1509
if name_pattern is None:
1510
raise BzrCommandError("ignore requires a NAME_PATTERN")
2610
1511
tree, relpath = WorkingTree.open_containing(u'.')
2611
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2612
ignored = globbing.Globster(name_pattern_list)
2613
matches = []
2614
tree.lock_read()
2615
for entry in tree.list_files():
2616
id = entry[3]
2617
if id is not None:
2618
filename = entry[0]
2619
if ignored.match(filename):
2620
matches.append(filename.encode('utf-8'))
2621
tree.unlock()
2622
if len(matches) > 0:
2623
print "Warning: the following files are version controlled and" \
2624
" match your ignore pattern:\n%s" \
2625
"\nThese files will continue to be version controlled" \
2626
" unless you 'bzr remove' them." % ("\n".join(matches),)
1512
ifn = tree.abspath('.bzrignore')
1513
if os.path.exists(ifn):
1514
f = open(ifn, 'rt')
1515
try:
1516
igns = f.read().decode('utf-8')
1517
finally:
1518
f.close()
1519
else:
1520
igns = ''
1521
1522
# TODO: If the file already uses crlf-style termination, maybe
1523
# we should use that for the newly added lines?
1524
1525
if igns and igns[-1] != '\n':
1526
igns += '\n'
1527
igns += name_pattern + '\n'
1528
1529
f = AtomicFile(ifn, 'wt')
1530
try:
1531
f.write(igns.encode('utf-8'))
1532
f.commit()
1533
finally:
1534
f.close()
1535
1536
inv = tree.inventory
1537
if inv.path2id('.bzrignore'):
1538
mutter('.bzrignore is already versioned')
1539
else:
1540
mutter('need to make new .bzrignore file versioned')
1541
tree.add(['.bzrignore'])
2627
1542
2628
1543
2629
1544
class cmd_ignored(Command):
2630
1545
"""List ignored files and the patterns that matched them.
2631
1546
2632
List all the ignored files and the ignore pattern that caused the file to
2633
be ignored.
2634
2635
Alternatively, to list just the files::
2636
2637
bzr ls --ignored
2638
"""
2639
2640
encoding_type = 'replace'
2641
_see_also = ['ignore', 'ls']
2642
1547
See also: bzr ignore"""
2643
1548
@display_command
2644
1549
def run(self):
2645
1550
tree = WorkingTree.open_containing(u'.')[0]
2646
tree.lock_read()
2647
try:
2648
for path, file_class, kind, file_id, entry in tree.list_files():
2649
if file_class != 'I':
2650
continue
2651
## XXX: Slightly inefficient since this was already calculated
2652
pat = tree.is_ignored(path)
2653
self.outf.write('%-50s %s\n' % (path, pat))
2654
finally:
2655
tree.unlock()
1551
for path, file_class, kind, file_id, entry in tree.list_files():
1552
if file_class != 'I':
1553
continue
1554
## XXX: Slightly inefficient since this was already calculated
1555
pat = tree.is_ignored(path)
1556
print '%-50s %s' % (path, pat)
2656
1557
2657
1558
2658
1559
class cmd_lookup_revision(Command):
2659
1560
"""Lookup the revision-id from a revision-number
2660
1561
2661
:Examples:
1562
example:
2662
1563
bzr lookup-revision 33
2663
1564
"""
2664
1565
hidden = True
2665
1566
takes_args = ['revno']
2666
1567
2667
1568
@display_command
2668
1569
def run(self, revno):
2669
1570
try:
2670
1571
revno = int(revno)
2671
1572
except ValueError:
2672
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
1573
raise BzrCommandError("not a valid revision-number: %r" % revno)
2673
1574
2674
1575
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2675
1576
2676
1577
2677
1578
class cmd_export(Command):
2678
"""Export current or past revision to a destination directory or archive.
1579
"""Export past revision to destination directory.
2679
1580
2680
1581
If no revision is specified this exports the last committed revision.
2681
1582
2683
1584
given, try to find the format with the extension. If no extension
2684
1585
is found exports to a directory (equivalent to --format=dir).
2685
1586
2686
If root is supplied, it will be used as the root directory inside
2687
container formats (tar, zip, etc). If it is not supplied it will default
2688
to the exported filename. The root option has no effect for 'dir' format.
2689
2690
If branch is omitted then the branch containing the current working
2691
directory will be used.
2692
2693
Note: Export of tree with non-ASCII filenames to zip is not supported.
2694
2695
================= =========================
2696
Supported formats Autodetected by extension
2697
================= =========================
2698
dir (none)
1587
Root may be the top directory for tar, tgz and tbz2 formats. If none
1588
is given, the top directory will be the root name of the file.
1589
1590
Note: export of tree with non-ascii filenames to zip is not supported.
1591
1592
Supported formats Autodetected by extension
1593
----------------- -------------------------
1594
dir -
2699
1595
tar .tar
2700
1596
tbz2 .tar.bz2, .tbz2
2701
1597
tgz .tar.gz, .tgz
2702
1598
zip .zip
2703
================= =========================
2704
1599
"""
2705
takes_args = ['dest', 'branch_or_subdir?']
2706
takes_options = [
2707
Option('format',
2708
help="Type of file to export to.",
2709
type=unicode),
2710
'revision',
2711
Option('filters', help='Apply content filters to export the '
2712
'convenient form.'),
2713
Option('root',
2714
type=str,
2715
help="Name of the root directory inside the exported file."),
2716
]
2717
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2718
root=None, filters=False):
1600
takes_args = ['dest']
1601
takes_options = ['revision', 'format', 'root']
1602
def run(self, dest, revision=None, format=None, root=None):
2719
1603
from bzrlib.export import export
2720
2721
if branch_or_subdir is None:
2722
tree = WorkingTree.open_containing(u'.')[0]
2723
b = tree.branch
2724
subdir = None
1604
tree = WorkingTree.open_containing(u'.')[0]
1605
b = tree.branch
1606
if revision is None:
1607
# should be tree.last_revision FIXME
1608
rev_id = b.last_revision()
2725
1609
else:
2726
b, subdir = Branch.open_containing(branch_or_subdir)
2727
tree = None
2728
2729
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
1610
if len(revision) != 1:
1611
raise BzrError('bzr export --revision takes exactly 1 argument')
1612
rev_id = revision[0].in_history(b).rev_id
1613
t = b.repository.revision_tree(rev_id)
2730
1614
try:
2731
export(rev_tree, dest, format, root, subdir, filtered=filters)
1615
export(t, dest, format, root)
2732
1616
except errors.NoSuchExportFormat, e:
2733
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
1617
raise BzrCommandError('Unsupported export format: %s' % e.format)
2734
1618
2735
1619
2736
1620
class cmd_cat(Command):
2737
"""Write the contents of a file as of a given revision to standard output.
2738
2739
If no revision is nominated, the last revision is used.
2740
2741
Note: Take care to redirect standard output when using this command on a
2742
binary file.
2743
"""
2744
2745
_see_also = ['ls']
2746
takes_options = [
2747
Option('name-from-revision', help='The path name in the old tree.'),
2748
Option('filters', help='Apply content filters to display the '
2749
'convenience form.'),
2750
'revision',
2751
]
1621
"""Write a file's text from a previous revision."""
1622
1623
takes_options = ['revision']
2752
1624
takes_args = ['filename']
2753
encoding_type = 'exact'
2754
1625
2755
1626
@display_command
2756
def run(self, filename, revision=None, name_from_revision=False,
2757
filters=False):
1627
def run(self, filename, revision=None):
2758
1628
if revision is not None and len(revision) != 1:
2759
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2760
" one revision specifier")
2761
tree, branch, relpath = \
2762
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2763
branch.lock_read()
1629
raise BzrCommandError("bzr cat --revision takes exactly one number")
1630
tree = None
2764
1631
try:
2765
return self._run(tree, branch, relpath, filename, revision,
2766
name_from_revision, filters)
2767
finally:
2768
branch.unlock()
1632
tree, relpath = WorkingTree.open_containing(filename)
1633
b = tree.branch
1634
except NotBranchError:
1635
pass
2769
1636
2770
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2771
filtered):
2772
1637
if tree is None:
2773
tree = b.basis_tree()
2774
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2775
2776
old_file_id = rev_tree.path2id(relpath)
2777
2778
if name_from_revision:
2779
# Try in revision if requested
2780
if old_file_id is None:
2781
raise errors.BzrCommandError(
2782
"%r is not present in revision %s" % (
2783
filename, rev_tree.get_revision_id()))
2784
else:
2785
content = rev_tree.get_file_text(old_file_id)
2786
else:
2787
cur_file_id = tree.path2id(relpath)
2788
found = False
2789
if cur_file_id is not None:
2790
# Then try with the actual file id
2791
try:
2792
content = rev_tree.get_file_text(cur_file_id)
2793
found = True
2794
except errors.NoSuchId:
2795
# The actual file id didn't exist at that time
2796
pass
2797
if not found and old_file_id is not None:
2798
# Finally try with the old file id
2799
content = rev_tree.get_file_text(old_file_id)
2800
found = True
2801
if not found:
2802
# Can't be found anywhere
2803
raise errors.BzrCommandError(
2804
"%r is not present in revision %s" % (
2805
filename, rev_tree.get_revision_id()))
2806
if filtered:
2807
from bzrlib.filters import (
2808
ContentFilterContext,
2809
filtered_output_bytes,
2810
)
2811
filters = rev_tree._content_filter_stack(relpath)
2812
chunks = content.splitlines(True)
2813
content = filtered_output_bytes(chunks, filters,
2814
ContentFilterContext(relpath, rev_tree))
2815
self.outf.writelines(content)
2816
else:
2817
self.outf.write(content)
1638
b, relpath = Branch.open_containing(filename)
1639
if revision is None:
1640
revision_id = b.last_revision()
1641
else:
1642
revision_id = revision[0].in_history(b).rev_id
1643
b.print_file(relpath, revision_id)
2818
1644
2819
1645
2820
1646
class cmd_local_time_offset(Command):
2821
1647
"""Show the offset in seconds from GMT to local time."""
2822
hidden = True
1648
hidden = True
2823
1649
@display_command
2824
1650
def run(self):
2825
1651
print osutils.local_time_offset()
2828
1654
2829
1655
class cmd_commit(Command):
2830
1656
"""Commit changes into a new revision.
2831
2832
An explanatory message needs to be given for each commit. This is
2833
often done by using the --message option (getting the message from the
2834
command line) or by using the --file option (getting the message from
2835
a file). If neither of these options is given, an editor is opened for
2836
the user to enter the message. To see the changed files in the
2837
boilerplate text loaded into the editor, use the --show-diff option.
2838
2839
By default, the entire tree is committed and the person doing the
2840
commit is assumed to be the author. These defaults can be overridden
2841
as explained below.
2842
2843
:Selective commits:
2844
2845
If selected files are specified, only changes to those files are
2846
committed. If a directory is specified then the directory and
2847
everything within it is committed.
2848
2849
When excludes are given, they take precedence over selected files.
2850
For example, to commit only changes within foo, but not changes
2851
within foo/bar::
2852
2853
bzr commit foo -x foo/bar
2854
2855
A selective commit after a merge is not yet supported.
2856
2857
:Custom authors:
2858
2859
If the author of the change is not the same person as the committer,
2860
you can specify the author's name using the --author option. The
2861
name should be in the same format as a committer-id, e.g.
2862
"John Doe <jdoe@example.com>". If there is more than one author of
2863
the change you can specify the option multiple times, once for each
2864
author.
2865
2866
:Checks:
2867
2868
A common mistake is to forget to add a new file or directory before
2869
running the commit command. The --strict option checks for unknown
2870
files and aborts the commit if any are found. More advanced pre-commit
2871
checks can be implemented by defining hooks. See ``bzr help hooks``
2872
for details.
2873
2874
:Things to note:
2875
2876
If you accidentially commit the wrong changes or make a spelling
2877
mistake in the commit message say, you can use the uncommit command
2878
to undo it. See ``bzr help uncommit`` for details.
2879
2880
Hooks can also be configured to run after a commit. This allows you
2881
to trigger updates to external systems like bug trackers. The --fixes
2882
option can be used to record the association between a revision and
2883
one or more bugs. See ``bzr help bugs`` for details.
2884
2885
A selective commit may fail in some cases where the committed
2886
tree would be invalid. Consider::
2887
2888
bzr init foo
2889
mkdir foo/bar
2890
bzr add foo/bar
2891
bzr commit foo -m "committing foo"
2892
bzr mv foo/bar foo/baz
2893
mkdir foo/bar
2894
bzr add foo/bar
2895
bzr commit foo/bar -m "committing bar but not baz"
2896
2897
In the example above, the last commit will fail by design. This gives
2898
the user the opportunity to decide whether they want to commit the
2899
rename at the same time, separately first, or not at all. (As a general
2900
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
1657
1658
If no arguments are given, the entire tree is committed.
1659
1660
If selected files are specified, only changes to those files are
1661
committed. If a directory is specified then the directory and everything
1662
within it is committed.
1663
1664
A selected-file commit may fail in some cases where the committed
1665
tree would be invalid, such as trying to commit a file in a
1666
newly-added directory that is not itself committed.
2901
1667
"""
2902
1668
# TODO: Run hooks on tree to-be-committed, and after commit.
2903
1669
2908
1674
2909
1675
# XXX: verbose currently does nothing
2910
1676
2911
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
2912
1677
takes_args = ['selected*']
2913
takes_options = [
2914
ListOption('exclude', type=str, short_name='x',
2915
help="Do not consider changes made to a given path."),
2916
Option('message', type=unicode,
2917
short_name='m',
2918
help="Description of the new revision."),
2919
'verbose',
2920
Option('unchanged',
2921
help='Commit even if nothing has changed.'),
2922
Option('file', type=str,
2923
short_name='F',
2924
argname='msgfile',
2925
help='Take commit message from this file.'),
2926
Option('strict',
2927
help="Refuse to commit if there are unknown "
2928
"files in the working tree."),
2929
ListOption('fixes', type=str,
2930
help="Mark a bug as being fixed by this revision "
2931
"(see \"bzr help bugs\")."),
2932
ListOption('author', type=unicode,
2933
help="Set the author's name, if it's different "
2934
"from the committer."),
2935
Option('local',
2936
help="Perform a local commit in a bound "
2937
"branch. Local commits are not pushed to "
2938
"the master branch until a normal commit "
2939
"is performed."
2940
),
2941
Option('show-diff',
2942
help='When no message is supplied, show the diff along'
2943
' with the status summary in the message editor.'),
2944
]
1678
takes_options = ['message', 'verbose',
1679
Option('unchanged',
1680
help='commit even if nothing has changed'),
1681
Option('file', type=str,
1682
argname='msgfile',
1683
help='file containing commit message'),
1684
Option('strict',
1685
help="refuse to commit if there are unknown "
1686
"files in the working tree."),
1687
Option('local',
1688
help="perform a local only commit in a bound "
1689
"branch. Such commits are not pushed to "
1690
"the master branch until a normal commit "
1691
"is performed."
1692
),
1693
]
2945
1694
aliases = ['ci', 'checkin']
2946
1695
2947
def _iter_bug_fix_urls(self, fixes, branch):
2948
# Configure the properties for bug fixing attributes.
2949
for fixed_bug in fixes:
2950
tokens = fixed_bug.split(':')
2951
if len(tokens) != 2:
2952
raise errors.BzrCommandError(
2953
"Invalid bug %s. Must be in the form of 'tracker:id'. "
2954
"See \"bzr help bugs\" for more information on this "
2955
"feature.\nCommit refused." % fixed_bug)
2956
tag, bug_id = tokens
2957
try:
2958
yield bugtracker.get_bug_url(tag, branch, bug_id)
2959
except errors.UnknownBugTrackerAbbreviation:
2960
raise errors.BzrCommandError(
2961
'Unrecognized bug %s. Commit refused.' % fixed_bug)
2962
except errors.MalformedBugIdentifier, e:
2963
raise errors.BzrCommandError(
2964
"%s\nCommit refused." % (str(e),))
2965
2966
def run(self, message=None, file=None, verbose=False, selected_list=None,
2967
unchanged=False, strict=False, local=False, fixes=None,
2968
author=None, show_diff=False, exclude=None):
2969
from bzrlib.errors import (
2970
PointlessCommit,
2971
ConflictsInTree,
2972
StrictCommitFailed
2973
)
2974
from bzrlib.msgeditor import (
2975
edit_commit_message_encoded,
2976
generate_commit_message_template,
2977
make_commit_message_template_encoded
2978
)
1696
def run(self, message=None, file=None, verbose=True, selected_list=None,
1697
unchanged=False, strict=False, local=False):
1698
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1699
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1700
StrictCommitFailed)
1701
from bzrlib.msgeditor import edit_commit_message, \
1702
make_commit_message_template
1703
from tempfile import TemporaryFile
2979
1704
2980
1705
# TODO: Need a blackbox test for invoking the external editor; may be
2981
1706
# slightly problematic to run this cross-platform.
2982
1707
2983
# TODO: do more checks that the commit will succeed before
1708
# TODO: do more checks that the commit will succeed before
2984
1709
# spending the user's valuable time typing a commit message.
2985
2986
properties = {}
2987
1710
#
1711
# TODO: if the commit *does* happen to fail, then save the commit
1712
# message to a temporary file where it can be recovered
2988
1713
tree, selected_list = tree_files(selected_list)
2989
1714
if selected_list == ['']:
2990
1715
# workaround - commit of root of tree should be exactly the same
2992
1717
# selected-file merge commit is not done yet
2993
1718
selected_list = []
2994
1719
2995
if fixes is None:
2996
fixes = []
2997
bug_property = bugtracker.encode_fixes_bug_urls(
2998
self._iter_bug_fix_urls(fixes, tree.branch))
2999
if bug_property:
3000
properties['bugs'] = bug_property
3001
3002
1720
if local and not tree.branch.get_bound_location():
3003
1721
raise errors.LocalRequiresBoundBranch()
3004
3005
def get_message(commit_obj):
3006
"""Callback to get commit message"""
3007
my_message = message
3008
if my_message is None and not file:
3009
t = make_commit_message_template_encoded(tree,
3010
selected_list, diff=show_diff,
3011
output_encoding=osutils.get_user_encoding())
3012
start_message = generate_commit_message_template(commit_obj)
3013
my_message = edit_commit_message_encoded(t,
3014
start_message=start_message)
3015
if my_message is None:
3016
raise errors.BzrCommandError("please specify a commit"
3017
" message with either --message or --file")
3018
elif my_message and file:
3019
raise errors.BzrCommandError(
3020
"please specify either --message or --file")
3021
if file:
3022
my_message = codecs.open(file, 'rt',
3023
osutils.get_user_encoding()).read()
3024
if my_message == "":
3025
raise errors.BzrCommandError("empty commit message specified")
3026
return my_message
3027
1722
if message is None and not file:
1723
template = make_commit_message_template(tree, selected_list)
1724
message = edit_commit_message(template)
1725
if message is None:
1726
raise BzrCommandError("please specify a commit message"
1727
" with either --message or --file")
1728
elif message and file:
1729
raise BzrCommandError("please specify either --message or --file")
1730
1731
if file:
1732
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1733
1734
if message == "":
1735
raise BzrCommandError("empty commit message specified")
1736
1737
if verbose:
1738
reporter = ReportCommitToLog()
1739
else:
1740
reporter = NullCommitReporter()
1741
3028
1742
try:
3029
tree.commit(message_callback=get_message,
3030
specific_files=selected_list,
1743
tree.commit(message, specific_files=selected_list,
3031
1744
allow_pointless=unchanged, strict=strict, local=local,
3032
reporter=None, verbose=verbose, revprops=properties,
3033
authors=author,
3034
exclude=safe_relpath_files(tree, exclude))
1745
reporter=reporter)
3035
1746
except PointlessCommit:
3036
1747
# FIXME: This should really happen before the file is read in;
3037
1748
# perhaps prepare the commit; get the message; then actually commit
3038
raise errors.BzrCommandError("No changes to commit."
3039
" Use --unchanged to commit anyhow.")
1749
raise BzrCommandError("no changes to commit."
1750
" use --unchanged to commit anyhow")
3040
1751
except ConflictsInTree:
3041
raise errors.BzrCommandError('Conflicts detected in working '
3042
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3043
' resolve.')
1752
raise BzrCommandError("Conflicts detected in working tree. "
1753
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
3044
1754
except StrictCommitFailed:
3045
raise errors.BzrCommandError("Commit refused because there are"
3046
" unknown files in the working tree.")
1755
raise BzrCommandError("Commit refused because there are unknown "
1756
"files in the working tree.")
3047
1757
except errors.BoundBranchOutOfDate, e:
3048
raise errors.BzrCommandError(str(e) + "\n"
3049
'To commit to master branch, run update and then commit.\n'
3050
'You can also pass --local to commit to continue working '
3051
'disconnected.')
1758
raise BzrCommandError(str(e)
1759
+ ' Either unbind, update, or'
1760
' pass --local to commit.')
3052
1761
3053
1762
3054
1763
class cmd_check(Command):
3055
"""Validate working tree structure, branch consistency and repository history.
3056
3057
This command checks various invariants about branch and repository storage
3058
to detect data corruption or bzr bugs.
3059
3060
The working tree and branch checks will only give output if a problem is
3061
detected. The output fields of the repository check are:
3062
3063
revisions
3064
This is just the number of revisions checked. It doesn't
3065
indicate a problem.
3066
3067
versionedfiles
3068
This is just the number of versionedfiles checked. It
3069
doesn't indicate a problem.
3070
3071
unreferenced ancestors
3072
Texts that are ancestors of other texts, but
3073
are not properly referenced by the revision ancestry. This is a
3074
subtle problem that Bazaar can work around.
3075
3076
unique file texts
3077
This is the total number of unique file contents
3078
seen in the checked revisions. It does not indicate a problem.
3079
3080
repeated file texts
3081
This is the total number of repeated texts seen
3082
in the checked revisions. Texts can be repeated when their file
3083
entries are modified, but the file contents are not. It does not
3084
indicate a problem.
3085
3086
If no restrictions are specified, all Bazaar data that is found at the given
3087
location will be checked.
3088
3089
:Examples:
3090
3091
Check the tree and branch at 'foo'::
3092
3093
bzr check --tree --branch foo
3094
3095
Check only the repository at 'bar'::
3096
3097
bzr check --repo bar
3098
3099
Check everything at 'baz'::
3100
3101
bzr check baz
1764
"""Validate consistency of branch history.
1765
1766
This command checks various invariants about the branch storage to
1767
detect data corruption or bzr bugs.
3102
1768
"""
3103
3104
_see_also = ['reconcile']
3105
takes_args = ['path?']
3106
takes_options = ['verbose',
3107
Option('branch', help="Check the branch related to the"
3108
" current directory."),
3109
Option('repo', help="Check the repository related to the"
3110
" current directory."),
3111
Option('tree', help="Check the working tree related to"
3112
" the current directory.")]
3113
3114
def run(self, path=None, verbose=False, branch=False, repo=False,
3115
tree=False):
3116
from bzrlib.check import check_dwim
3117
if path is None:
3118
path = '.'
3119
if not branch and not repo and not tree:
3120
branch = repo = tree = True
3121
check_dwim(path, verbose, do_branch=branch, do_repo=repo, do_tree=tree)
1769
takes_args = ['branch?']
1770
takes_options = ['verbose']
1771
1772
def run(self, branch=None, verbose=False):
1773
from bzrlib.check import check
1774
if branch is None:
1775
tree = WorkingTree.open_containing()[0]
1776
branch = tree.branch
1777
else:
1778
branch = Branch.open(branch)
1779
check(branch, verbose)
1780
1781
1782
class cmd_scan_cache(Command):
1783
hidden = True
1784
def run(self):
1785
from bzrlib.hashcache import HashCache
1786
1787
c = HashCache(u'.')
1788
c.read()
1789
c.scan()
1790
1791
print '%6d stats' % c.stat_count
1792
print '%6d in hashcache' % len(c._cache)
1793
print '%6d files removed from cache' % c.removed_count
1794
print '%6d hashes updated' % c.update_count
1795
print '%6d files changed too recently to cache' % c.danger_count
1796
1797
if c.needs_write:
1798
c.write()
3122
1799
3123
1800
3124
1801
class cmd_upgrade(Command):
3128
1805
this command. When the default format has changed you may also be warned
3129
1806
during other operations to upgrade.
3130
1807
"""
3131
3132
_see_also = ['check']
3133
1808
takes_args = ['url?']
3134
1809
takes_options = [
3135
RegistryOption('format',
3136
help='Upgrade to a specific format. See "bzr help'
3137
' formats" for details.',
3138
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3139
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3140
value_switches=True, title='Branch format'),
1810
Option('format',
1811
help='Upgrade to a specific format. Current formats'
1812
' are: default, knit, metaweave and weave.'
1813
' Default is knit; metaweave and weave are'
1814
' deprecated',
1815
type=get_format_type),
3141
1816
]
3142
1817
1818
3143
1819
def run(self, url='.', format=None):
3144
1820
from bzrlib.upgrade import upgrade
1821
if format is None:
1822
format = get_format_type('default')
3145
1823
upgrade(url, format)
3146
1824
3147
1825
3148
1826
class cmd_whoami(Command):
3149
1827
"""Show or set bzr user id.
3150
3151
:Examples:
3152
Show the email of the current user::
3153
3154
bzr whoami --email
3155
3156
Set the current user::
3157
3158
bzr whoami "Frank Chu <fchu@example.com>"
1828
1829
examples:
1830
bzr whoami --email
1831
bzr whoami 'Frank Chu <fchu@example.com>'
3159
1832
"""
3160
1833
takes_options = [ Option('email',
3161
help='Display email address only.'),
1834
help='display email address only'),
3162
1835
Option('branch',
3163
help='Set identity for the current branch instead of '
3164
'globally.'),
1836
help='set identity for the current branch instead of '
1837
'globally'),
3165
1838
]
3166
1839
takes_args = ['name?']
3167
1840
encoding_type = 'replace'
3168
1841
3169
1842
@display_command
3170
1843
def run(self, email=False, branch=False, name=None):
3171
1844
if name is None:
3172
1845
# use branch if we're inside one; otherwise global config
3173
1846
try:
3174
1847
c = Branch.open_containing('.')[0].get_config()
3175
except errors.NotBranchError:
1848
except NotBranchError:
3176
1849
c = config.GlobalConfig()
3177
1850
if email:
3178
1851
self.outf.write(c.user_email() + '\n')
3183
1856
# display a warning if an email address isn't included in the given name.
3184
1857
try:
3185
1858
config.extract_email_address(name)
3186
except errors.NoEmailInUsername, e:
1859
except BzrError, e:
3187
1860
warning('"%s" does not seem to contain an email address. '
3188
1861
'This is allowed, but not recommended.', name)
3189
1862
3190
1863
# use global config unless --branch given
3191
1864
if branch:
3192
1865
c = Branch.open_containing('.')[0].get_config()
3196
1869
3197
1870
3198
1871
class cmd_nick(Command):
3199
"""Print or set the branch nickname.
3200
3201
If unset, the tree root directory name is used as the nickname.
3202
To print the current nickname, execute with no argument.
3203
3204
Bound branches use the nickname of its master branch unless it is set
3205
locally.
1872
"""Print or set the branch nickname.
1873
1874
If unset, the tree root directory name is used as the nickname
1875
To print the current nickname, execute with no argument.
3206
1876
"""
3207
3208
_see_also = ['info']
3209
1877
takes_args = ['nickname?']
3210
1878
def run(self, nickname=None):
3211
1879
branch = Branch.open_containing(u'.')[0]
3216
1884
3217
1885
@display_command
3218
1886
def printme(self, branch):
3219
print branch.nick
3220
3221
3222
class cmd_alias(Command):
3223
"""Set/unset and display aliases.
3224
3225
:Examples:
3226
Show the current aliases::
3227
3228
bzr alias
3229
3230
Show the alias specified for 'll'::
3231
3232
bzr alias ll
3233
3234
Set an alias for 'll'::
3235
3236
bzr alias ll="log --line -r-10..-1"
3237
3238
To remove an alias for 'll'::
3239
3240
bzr alias --remove ll
3241
3242
"""
3243
takes_args = ['name?']
3244
takes_options = [
3245
Option('remove', help='Remove the alias.'),
3246
]
3247
3248
def run(self, name=None, remove=False):
3249
if remove:
3250
self.remove_alias(name)
3251
elif name is None:
3252
self.print_aliases()
3253
else:
3254
equal_pos = name.find('=')
3255
if equal_pos == -1:
3256
self.print_alias(name)
3257
else:
3258
self.set_alias(name[:equal_pos], name[equal_pos+1:])
3259
3260
def remove_alias(self, alias_name):
3261
if alias_name is None:
3262
raise errors.BzrCommandError(
3263
'bzr alias --remove expects an alias to remove.')
3264
# If alias is not found, print something like:
3265
# unalias: foo: not found
3266
c = config.GlobalConfig()
3267
c.unset_alias(alias_name)
3268
3269
@display_command
3270
def print_aliases(self):
3271
"""Print out the defined aliases in a similar format to bash."""
3272
aliases = config.GlobalConfig().get_aliases()
3273
for key, value in sorted(aliases.iteritems()):
3274
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3275
3276
@display_command
3277
def print_alias(self, alias_name):
3278
from bzrlib.commands import get_alias
3279
alias = get_alias(alias_name)
3280
if alias is None:
3281
self.outf.write("bzr alias: %s: not found\n" % alias_name)
3282
else:
3283
self.outf.write(
3284
'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
3285
3286
def set_alias(self, alias_name, alias_command):
3287
"""Save the alias in the global config."""
3288
c = config.GlobalConfig()
3289
c.set_alias(alias_name, alias_command)
1887
print branch.nick
3290
1888
3291
1889
3292
1890
class cmd_selftest(Command):
3293
1891
"""Run internal test suite.
3294
3295
If arguments are given, they are regular expressions that say which tests
3296
should run. Tests matching any expression are run, and other tests are
3297
not run.
3298
3299
Alternatively if --first is given, matching tests are run first and then
3300
all other tests are run. This is useful if you have been working in a
3301
particular area, but want to make sure nothing else was broken.
3302
3303
If --exclude is given, tests that match that regular expression are
3304
excluded, regardless of whether they match --first or not.
3305
3306
To help catch accidential dependencies between tests, the --randomize
3307
option is useful. In most cases, the argument used is the word 'now'.
3308
Note that the seed used for the random number generator is displayed
3309
when this option is used. The seed can be explicitly passed as the
3310
argument to this option if required. This enables reproduction of the
3311
actual ordering used if and when an order sensitive problem is encountered.
3312
3313
If --list-only is given, the tests that would be run are listed. This is
3314
useful when combined with --first, --exclude and/or --randomize to
3315
understand their impact. The test harness reports "Listed nn tests in ..."
3316
instead of "Ran nn tests in ..." when list mode is enabled.
1892
1893
This creates temporary test directories in the working directory,
1894
but not existing data is affected. These directories are deleted
1895
if the tests pass, or left behind to help in debugging if they
1896
fail and --keep-output is specified.
1897
1898
If arguments are given, they are regular expressions that say
1899
which tests should run.
3317
1900
3318
1901
If the global option '--no-plugins' is given, plugins are not loaded
3319
1902
before running the selftests. This has two effects: features provided or
3320
1903
modified by plugins will not be tested, and tests provided by plugins will
3321
1904
not be run.
3322
1905
3323
Tests that need working space on disk use a common temporary directory,
3324
typically inside $TMPDIR or /tmp.
3325
3326
:Examples:
3327
Run only tests relating to 'ignore'::
3328
3329
bzr selftest ignore
3330
3331
Disable plugins and list tests as they're run::
3332
3333
bzr --no-plugins selftest -v
1906
examples:
1907
bzr selftest ignore
1908
bzr --no-plugins selftest -v
3334
1909
"""
1910
# TODO: --list should give a list of all available tests
1911
3335
1912
# NB: this is used from the class without creating an instance, which is
3336
1913
# why it does not have a self parameter.
3337
1914
def get_transport_type(typestring):
3347
1924
return FakeNFSServer
3348
1925
msg = "No known transport type %s. Supported types are: sftp\n" %\
3349
1926
(typestring)
3350
raise errors.BzrCommandError(msg)
1927
raise BzrCommandError(msg)
3351
1928
3352
1929
hidden = True
3353
1930
takes_args = ['testspecs*']
3354
1931
takes_options = ['verbose',
3355
Option('one',
3356
help='Stop when one test fails.',
3357
short_name='1',
3358
),
3359
Option('transport',
1932
Option('one', help='stop when one test fails'),
1933
Option('keep-output',
1934
help='keep output directories when tests fail'),
1935
Option('transport',
3360
1936
help='Use a different transport by default '
3361
1937
'throughout the test suite.',
3362
1938
type=get_transport_type),
3363
Option('benchmark',
3364
help='Run the benchmarks rather than selftests.'),
1939
Option('benchmark', help='run the bzr bencharks.'),
3365
1940
Option('lsprof-timed',
3366
help='Generate lsprof output for benchmarked'
1941
help='generate lsprof output for benchmarked'
3367
1942
' sections of code.'),
3368
Option('cache-dir', type=str,
3369
help='Cache intermediate benchmark output in this '
3370
'directory.'),
3371
Option('first',
3372
help='Run all tests, but run specified tests first.',
3373
short_name='f',
3374
),
3375
Option('list-only',
3376
help='List the tests instead of running them.'),
3377
RegistryOption('parallel',
3378
help="Run the test suite in parallel.",
3379
lazy_registry=('bzrlib.tests', 'parallel_registry'),
3380
value_switches=False,
3381
),
3382
Option('randomize', type=str, argname="SEED",
3383
help='Randomize the order of tests using the given'
3384
' seed or "now" for the current time.'),
3385
Option('exclude', type=str, argname="PATTERN",
3386
short_name='x',
3387
help='Exclude tests that match this regular'
3388
' expression.'),
3389
Option('subunit',
3390
help='Output test progress via subunit.'),
3391
Option('strict', help='Fail on missing dependencies or '
3392
'known failures.'),
3393
Option('load-list', type=str, argname='TESTLISTFILE',
3394
help='Load a test id list from a text file.'),
3395
ListOption('debugflag', type=str, short_name='E',
3396
help='Turn on a selftest debug flag.'),
3397
ListOption('starting-with', type=str, argname='TESTID',
3398
param_name='starting_with', short_name='s',
3399
help=
3400
'Load only the tests starting with TESTID.'),
3401
1943
]
3402
encoding_type = 'replace'
3403
3404
def __init__(self):
3405
Command.__init__(self)
3406
self.additional_selftest_args = {}
3407
3408
def run(self, testspecs_list=None, verbose=False, one=False,
3409
transport=None, benchmark=None,
3410
lsprof_timed=None, cache_dir=None,
3411
first=False, list_only=False,
3412
randomize=None, exclude=None, strict=False,
3413
load_list=None, debugflag=None, starting_with=None, subunit=False,
3414
parallel=None):
1944
1945
def run(self, testspecs_list=None, verbose=None, one=False,
1946
keep_output=False, transport=None, benchmark=None,
1947
lsprof_timed=None):
1948
import bzrlib.ui
3415
1949
from bzrlib.tests import selftest
3416
1950
import bzrlib.benchmarks as benchmarks
3417
from bzrlib.benchmarks import tree_creator
3418
3419
# Make deprecation warnings visible, unless -Werror is set
3420
symbol_versioning.activate_deprecation_warnings(override=False)
3421
3422
if cache_dir is not None:
3423
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3424
if testspecs_list is not None:
3425
pattern = '|'.join(testspecs_list)
3426
else:
3427
pattern = ".*"
3428
if subunit:
3429
try:
3430
from bzrlib.tests import SubUnitBzrRunner
3431
except ImportError:
3432
raise errors.BzrCommandError("subunit not available. subunit "
3433
"needs to be installed to use --subunit.")
3434
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3435
if parallel:
3436
self.additional_selftest_args.setdefault(
3437
'suite_decorators', []).append(parallel)
3438
if benchmark:
3439
test_suite_factory = benchmarks.test_suite
3440
# Unless user explicitly asks for quiet, be verbose in benchmarks
3441
verbose = not is_quiet()
3442
# TODO: should possibly lock the history file...
3443
benchfile = open(".perf_history", "at", buffering=1)
3444
else:
3445
test_suite_factory = None
3446
benchfile = None
1951
# we don't want progress meters from the tests to go to the
1952
# real output; and we don't want log messages cluttering up
1953
# the real logs.
1954
save_ui = ui.ui_factory
1955
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1956
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1957
print
1958
info('running tests...')
3447
1959
try:
3448
selftest_kwargs = {"verbose": verbose,
3449
"pattern": pattern,
3450
"stop_on_failure": one,
3451
"transport": transport,
3452
"test_suite_factory": test_suite_factory,
3453
"lsprof_timed": lsprof_timed,
3454
"bench_history": benchfile,
3455
"matching_tests_first": first,
3456
"list_only": list_only,
3457
"random_seed": randomize,
3458
"exclude_pattern": exclude,
3459
"strict": strict,
3460
"load_list": load_list,
3461
"debug_flags": debugflag,
3462
"starting_with": starting_with
3463
}
3464
selftest_kwargs.update(self.additional_selftest_args)
3465
result = selftest(**selftest_kwargs)
1960
ui.ui_factory = ui.SilentUIFactory()
1961
if testspecs_list is not None:
1962
pattern = '|'.join(testspecs_list)
1963
else:
1964
pattern = ".*"
1965
if benchmark:
1966
test_suite_factory = benchmarks.test_suite
1967
if verbose is None:
1968
verbose = True
1969
else:
1970
test_suite_factory = None
1971
if verbose is None:
1972
verbose = False
1973
result = selftest(verbose=verbose,
1974
pattern=pattern,
1975
stop_on_failure=one,
1976
keep_output=keep_output,
1977
transport=transport,
1978
test_suite_factory=test_suite_factory,
1979
lsprof_timed=lsprof_timed)
1980
if result:
1981
info('tests passed')
1982
else:
1983
info('tests failed')
1984
return int(not result)
3466
1985
finally:
3467
if benchfile is not None:
3468
benchfile.close()
3469
return int(not result)
1986
ui.ui_factory = save_ui
1987
1988
1989
def _get_bzr_branch():
1990
"""If bzr is run from a branch, return Branch or None"""
1991
from os.path import dirname
1992
1993
try:
1994
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1995
return branch
1996
except errors.BzrError:
1997
return None
1998
1999
2000
def show_version():
2001
import bzrlib
2002
print "Bazaar (bzr) %s" % bzrlib.__version__
2003
# is bzrlib itself in a branch?
2004
branch = _get_bzr_branch()
2005
if branch:
2006
rh = branch.revision_history()
2007
revno = len(rh)
2008
print " bzr checkout, revision %d" % (revno,)
2009
print " nick: %s" % (branch.nick,)
2010
if rh:
2011
print " revid: %s" % (rh[-1],)
2012
print "Using python interpreter:", sys.executable
2013
import site
2014
print "Using python standard library:", os.path.dirname(site.__file__)
2015
print "Using bzrlib:",
2016
if len(bzrlib.__path__) > 1:
2017
# print repr, which is a good enough way of making it clear it's
2018
# more than one element (eg ['/foo/bar', '/foo/bzr'])
2019
print repr(bzrlib.__path__)
2020
else:
2021
print bzrlib.__path__[0]
2022
2023
print
2024
print bzrlib.__copyright__
2025
print "http://bazaar-vcs.org/"
2026
print
2027
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
2028
print "you may use, modify and redistribute it under the terms of the GNU"
2029
print "General Public License version 2 or later."
3470
2030
3471
2031
3472
2032
class cmd_version(Command):
3473
2033
"""Show version of bzr."""
3474
2034
3475
encoding_type = 'replace'
3476
takes_options = [
3477
Option("short", help="Print just the version number."),
3478
]
3479
3480
2035
@display_command
3481
def run(self, short=False):
3482
from bzrlib.version import show_version
3483
if short:
3484
self.outf.write(bzrlib.version_string + '\n')
3485
else:
3486
show_version(to_file=self.outf)
2036
def run(self):
2037
show_version()
3487
2038
3488
2039
3489
2040
class cmd_rocks(Command):
3493
2044
3494
2045
@display_command
3495
2046
def run(self):
3496
print "It sure does!"
2047
print "it sure does!"
3497
2048
3498
2049
3499
2050
class cmd_find_merge_base(Command):
3502
2053
# merging only part of the history.
3503
2054
takes_args = ['branch', 'other']
3504
2055
hidden = True
3505
2056
3506
2057
@display_command
3507
2058
def run(self, branch, other):
3508
from bzrlib.revision import ensure_null
3509
2059
from bzrlib.revision import common_ancestor, MultipleRevisionSources
2060
3510
2061
branch1 = Branch.open_containing(branch)[0]
3511
2062
branch2 = Branch.open_containing(other)[0]
3512
branch1.lock_read()
3513
try:
3514
branch2.lock_read()
3515
try:
3516
last1 = ensure_null(branch1.last_revision())
3517
last2 = ensure_null(branch2.last_revision())
3518
3519
graph = branch1.repository.get_graph(branch2.repository)
3520
base_rev_id = graph.find_unique_lca(last1, last2)
3521
3522
print 'merge base is revision %s' % base_rev_id
3523
finally:
3524
branch2.unlock()
3525
finally:
3526
branch1.unlock()
2063
2064
history_1 = branch1.revision_history()
2065
history_2 = branch2.revision_history()
2066
2067
last1 = branch1.last_revision()
2068
last2 = branch2.last_revision()
2069
2070
source = MultipleRevisionSources(branch1.repository,
2071
branch2.repository)
2072
2073
base_rev_id = common_ancestor(last1, last2, source)
2074
2075
print 'merge base is revision %s' % base_rev_id
3527
2076
3528
2077
3529
2078
class cmd_merge(Command):
3530
2079
"""Perform a three-way merge.
3531
3532
The source of the merge can be specified either in the form of a branch,
3533
or in the form of a path to a file containing a merge directive generated
3534
with bzr send. If neither is specified, the default is the upstream branch
3535
or the branch most recently merged using --remember.
3536
3537
When merging a branch, by default the tip will be merged. To pick a different
3538
revision, pass --revision. If you specify two values, the first will be used as
3539
BASE and the second one as OTHER. Merging individual revisions, or a subset of
3540
available revisions, like this is commonly referred to as "cherrypicking".
3541
3542
Revision numbers are always relative to the branch being merged.
2080
2081
The branch is the branch you will merge from. By default, it will merge
2082
the latest revision. If you specify a revision, that revision will be
2083
merged. If you specify two revisions, the first will be used as a BASE,
2084
and the second one as OTHER. Revision numbers are always relative to the
2085
specified branch.
3543
2086
3544
2087
By default, bzr will try to merge in all new work from the other
3545
2088
branch, automatically determining an appropriate base. If this
3546
2089
fails, you may need to give an explicit base.
3547
2090
3548
2091
Merge will do its best to combine the changes in two branches, but there
3549
2092
are some kinds of problems only a human can fix. When it encounters those,
3550
2093
it will mark a conflict. A conflict means that you need to fix something,
3557
2100
default, use --remember. The value will only be saved if the remote
3558
2101
location can be accessed.
3559
2102
3560
The results of the merge are placed into the destination working
3561
directory, where they can be reviewed (with bzr diff), tested, and then
3562
committed to record the result of the merge.
3563
2103
Examples:
2104
2105
To merge the latest revision from bzr.dev
2106
bzr merge ../bzr.dev
2107
2108
To merge changes up to and including revision 82 from bzr.dev
2109
bzr merge -r 82 ../bzr.dev
2110
2111
To merge the changes introduced by 82, without previous changes:
2112
bzr merge -r 81..82 ../bzr.dev
2113
3564
2114
merge refuses to run if there are any uncommitted changes, unless
3565
2115
--force is given.
3566
2116
3567
To select only some changes to merge, use "merge -i", which will prompt
3568
you to apply each diff hunk and file change, similar to "shelve".
3569
3570
:Examples:
3571
To merge the latest revision from bzr.dev::
3572
3573
bzr merge ../bzr.dev
3574
3575
To merge changes up to and including revision 82 from bzr.dev::
3576
3577
bzr merge -r 82 ../bzr.dev
3578
3579
To merge the changes introduced by 82, without previous changes::
3580
3581
bzr merge -r 81..82 ../bzr.dev
3582
3583
To apply a merge directive contained in /tmp/merge:
3584
3585
bzr merge /tmp/merge
2117
The following merge types are available:
3586
2118
"""
3587
3588
encoding_type = 'exact'
3589
_see_also = ['update', 'remerge', 'status-flags', 'send']
3590
takes_args = ['location?']
3591
takes_options = [
3592
'change',
3593
'revision',
3594
Option('force',
3595
help='Merge even if the destination tree has uncommitted changes.'),
3596
'merge-type',
3597
'reprocess',
3598
'remember',
3599
Option('show-base', help="Show base revision text in "
3600
"conflicts."),
3601
Option('uncommitted', help='Apply uncommitted changes'
3602
' from a working copy, instead of branch changes.'),
3603
Option('pull', help='If the destination is already'
3604
' completely merged into the source, pull from the'
3605
' source rather than merging. When this happens,'
3606
' you do not need to commit the result.'),
3607
Option('directory',
3608
help='Branch to merge into, '
3609
'rather than the one containing the working directory.',
3610
short_name='d',
3611
type=unicode,
3612
),
3613
Option('preview', help='Instead of merging, show a diff of the'
3614
' merge.'),
3615
Option('interactive', help='Select changes interactively.',
3616
short_name='i')
3617
]
3618
3619
def run(self, location=None, revision=None, force=False,
3620
merge_type=None, show_base=False, reprocess=None, remember=False,
3621
uncommitted=False, pull=False,
3622
directory=None,
3623
preview=False,
3624
interactive=False,
3625
):
2119
takes_args = ['branch?']
2120
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
2121
Option('show-base', help="Show base revision text in "
2122
"conflicts")]
2123
2124
def help(self):
2125
from merge import merge_type_help
2126
from inspect import getdoc
2127
return getdoc(self) + '\n' + merge_type_help()
2128
2129
def run(self, branch=None, revision=None, force=False, merge_type=None,
2130
show_base=False, reprocess=False, remember=False):
3626
2131
if merge_type is None:
3627
merge_type = _mod_merge.Merge3Merger
3628
3629
if directory is None: directory = u'.'
3630
possible_transports = []
3631
merger = None
3632
allow_pending = True
3633
verified = 'inapplicable'
3634
tree = WorkingTree.open_containing(directory)[0]
3635
3636
# die as quickly as possible if there are uncommitted changes
3637
try:
3638
basis_tree = tree.revision_tree(tree.last_revision())
3639
except errors.NoSuchRevision:
3640
basis_tree = tree.basis_tree()
3641
if not force:
3642
if tree.has_changes(basis_tree):
3643
raise errors.UncommittedChanges(tree)
3644
3645
view_info = _get_view_info_for_change_reporter(tree)
3646
change_reporter = delta._ChangeReporter(
3647
unversioned_filter=tree.is_ignored, view_info=view_info)
3648
cleanups = []
3649
try:
3650
pb = ui.ui_factory.nested_progress_bar()
3651
cleanups.append(pb.finished)
3652
tree.lock_write()
3653
cleanups.append(tree.unlock)
3654
if location is not None:
3655
try:
3656
mergeable = bundle.read_mergeable_from_url(location,
3657
possible_transports=possible_transports)
3658
except errors.NotABundle:
3659
mergeable = None
2132
merge_type = Merge3Merger
2133
2134
tree = WorkingTree.open_containing(u'.')[0]
2135
2136
if branch is not None:
2137
try:
2138
reader = bundle.read_bundle_from_url(branch)
2139
except NotABundle:
2140
pass # Continue on considering this url a Branch
2141
else:
2142
conflicts = merge_bundle(reader, tree, not force, merge_type,
2143
reprocess, show_base)
2144
if conflicts == 0:
2145
return 0
3660
2146
else:
3661
if uncommitted:
3662
raise errors.BzrCommandError('Cannot use --uncommitted'
3663
' with bundles or merge directives.')
3664
3665
if revision is not None:
3666
raise errors.BzrCommandError(
3667
'Cannot use -r with merge directives or bundles')
3668
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3669
mergeable, pb)
3670
3671
if merger is None and uncommitted:
3672
if revision is not None and len(revision) > 0:
3673
raise errors.BzrCommandError('Cannot use --uncommitted and'
3674
' --revision at the same time.')
3675
merger = self.get_merger_from_uncommitted(tree, location, pb,
3676
cleanups)
3677
allow_pending = False
3678
3679
if merger is None:
3680
merger, allow_pending = self._get_merger_from_branch(tree,
3681
location, revision, remember, possible_transports, pb)
3682
3683
merger.merge_type = merge_type
3684
merger.reprocess = reprocess
3685
merger.show_base = show_base
3686
self.sanity_check_merger(merger)
3687
if (merger.base_rev_id == merger.other_rev_id and
3688
merger.other_rev_id is not None):
3689
note('Nothing to do.')
2147
return 1
2148
2149
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2150
2151
if revision is None or len(revision) < 1:
2152
base = [None, None]
2153
other = [branch, -1]
2154
other_branch, path = Branch.open_containing(branch)
2155
else:
2156
if len(revision) == 1:
2157
base = [None, None]
2158
other_branch, path = Branch.open_containing(branch)
2159
revno = revision[0].in_history(other_branch).revno
2160
other = [branch, revno]
2161
else:
2162
assert len(revision) == 2
2163
if None in revision:
2164
raise BzrCommandError(
2165
"Merge doesn't permit that revision specifier.")
2166
other_branch, path = Branch.open_containing(branch)
2167
2168
base = [branch, revision[0].in_history(other_branch).revno]
2169
other = [branch, revision[1].in_history(other_branch).revno]
2170
2171
if tree.branch.get_parent() is None or remember:
2172
tree.branch.set_parent(other_branch.base)
2173
2174
if path != "":
2175
interesting_files = [path]
2176
else:
2177
interesting_files = None
2178
pb = ui.ui_factory.nested_progress_bar()
2179
try:
2180
try:
2181
conflict_count = merge(other, base, check_clean=(not force),
2182
merge_type=merge_type,
2183
reprocess=reprocess,
2184
show_base=show_base,
2185
pb=pb, file_list=interesting_files)
2186
finally:
2187
pb.finished()
2188
if conflict_count != 0:
2189
return 1
2190
else:
3690
2191
return 0
3691
if pull:
3692
if merger.interesting_files is not None:
3693
raise errors.BzrCommandError('Cannot pull individual files')
3694
if (merger.base_rev_id == tree.last_revision()):
3695
result = tree.pull(merger.other_branch, False,
3696
merger.other_rev_id)
3697
result.report(self.outf)
3698
return 0
3699
merger.check_basis(False)
3700
if preview:
3701
return self._do_preview(merger, cleanups)
3702
elif interactive:
3703
return self._do_interactive(merger, cleanups)
3704
else:
3705
return self._do_merge(merger, change_reporter, allow_pending,
3706
verified)
3707
finally:
3708
for cleanup in reversed(cleanups):
3709
cleanup()
3710
3711
def _get_preview(self, merger, cleanups):
3712
tree_merger = merger.make_merger()
3713
tt = tree_merger.make_preview_transform()
3714
cleanups.append(tt.finalize)
3715
result_tree = tt.get_preview_tree()
3716
return result_tree
3717
3718
def _do_preview(self, merger, cleanups):
3719
from bzrlib.diff import show_diff_trees
3720
result_tree = self._get_preview(merger, cleanups)
3721
show_diff_trees(merger.this_tree, result_tree, self.outf,
3722
old_label='', new_label='')
3723
3724
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3725
merger.change_reporter = change_reporter
3726
conflict_count = merger.do_merge()
3727
if allow_pending:
3728
merger.set_pending()
3729
if verified == 'failed':
3730
warning('Preview patch does not match changes')
3731
if conflict_count != 0:
3732
return 1
3733
else:
3734
return 0
3735
3736
def _do_interactive(self, merger, cleanups):
3737
"""Perform an interactive merge.
3738
3739
This works by generating a preview tree of the merge, then using
3740
Shelver to selectively remove the differences between the working tree
3741
and the preview tree.
3742
"""
3743
from bzrlib import shelf_ui
3744
result_tree = self._get_preview(merger, cleanups)
3745
writer = bzrlib.option.diff_writer_registry.get()
3746
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3747
reporter=shelf_ui.ApplyReporter(),
3748
diff_writer=writer(sys.stdout))
3749
shelver.run()
3750
3751
def sanity_check_merger(self, merger):
3752
if (merger.show_base and
3753
not merger.merge_type is _mod_merge.Merge3Merger):
3754
raise errors.BzrCommandError("Show-base is not supported for this"
3755
" merge type. %s" % merger.merge_type)
3756
if merger.reprocess is None:
3757
if merger.show_base:
3758
merger.reprocess = False
3759
else:
3760
# Use reprocess if the merger supports it
3761
merger.reprocess = merger.merge_type.supports_reprocess
3762
if merger.reprocess and not merger.merge_type.supports_reprocess:
3763
raise errors.BzrCommandError("Conflict reduction is not supported"
3764
" for merge type %s." %
3765
merger.merge_type)
3766
if merger.reprocess and merger.show_base:
3767
raise errors.BzrCommandError("Cannot do conflict reduction and"
3768
" show base.")
3769
3770
def _get_merger_from_branch(self, tree, location, revision, remember,
3771
possible_transports, pb):
3772
"""Produce a merger from a location, assuming it refers to a branch."""
3773
from bzrlib.tag import _merge_tags_if_possible
3774
# find the branch locations
3775
other_loc, user_location = self._select_branch_location(tree, location,
3776
revision, -1)
3777
if revision is not None and len(revision) == 2:
3778
base_loc, _unused = self._select_branch_location(tree,
3779
location, revision, 0)
3780
else:
3781
base_loc = other_loc
3782
# Open the branches
3783
other_branch, other_path = Branch.open_containing(other_loc,
3784
possible_transports)
3785
if base_loc == other_loc:
3786
base_branch = other_branch
3787
else:
3788
base_branch, base_path = Branch.open_containing(base_loc,
3789
possible_transports)
3790
# Find the revision ids
3791
other_revision_id = None
3792
base_revision_id = None
3793
if revision is not None:
3794
if len(revision) >= 1:
3795
other_revision_id = revision[-1].as_revision_id(other_branch)
3796
if len(revision) == 2:
3797
base_revision_id = revision[0].as_revision_id(base_branch)
3798
if other_revision_id is None:
3799
other_revision_id = _mod_revision.ensure_null(
3800
other_branch.last_revision())
3801
# Remember where we merge from
3802
if ((remember or tree.branch.get_submit_branch() is None) and
3803
user_location is not None):
3804
tree.branch.set_submit_branch(other_branch.base)
3805
_merge_tags_if_possible(other_branch, tree.branch)
3806
merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3807
other_revision_id, base_revision_id, other_branch, base_branch)
3808
if other_path != '':
3809
allow_pending = False
3810
merger.interesting_files = [other_path]
3811
else:
3812
allow_pending = True
3813
return merger, allow_pending
3814
3815
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
3816
"""Get a merger for uncommitted changes.
3817
3818
:param tree: The tree the merger should apply to.
3819
:param location: The location containing uncommitted changes.
3820
:param pb: The progress bar to use for showing progress.
3821
:param cleanups: A list of operations to perform to clean up the
3822
temporary directories, unfinalized objects, etc.
3823
"""
3824
location = self._select_branch_location(tree, location)[0]
3825
other_tree, other_path = WorkingTree.open_containing(location)
3826
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree, pb)
3827
if other_path != '':
3828
merger.interesting_files = [other_path]
3829
return merger
3830
3831
def _select_branch_location(self, tree, user_location, revision=None,
3832
index=None):
3833
"""Select a branch location, according to possible inputs.
3834
3835
If provided, branches from ``revision`` are preferred. (Both
3836
``revision`` and ``index`` must be supplied.)
3837
3838
Otherwise, the ``location`` parameter is used. If it is None, then the
3839
``submit`` or ``parent`` location is used, and a note is printed.
3840
3841
:param tree: The working tree to select a branch for merging into
3842
:param location: The location entered by the user
3843
:param revision: The revision parameter to the command
3844
:param index: The index to use for the revision parameter. Negative
3845
indices are permitted.
3846
:return: (selected_location, user_location). The default location
3847
will be the user-entered location.
3848
"""
3849
if (revision is not None and index is not None
3850
and revision[index] is not None):
3851
branch = revision[index].get_branch()
3852
if branch is not None:
3853
return branch, branch
3854
if user_location is None:
3855
location = self._get_remembered(tree, 'Merging from')
3856
else:
3857
location = user_location
3858
return location, user_location
3859
3860
def _get_remembered(self, tree, verb_string):
2192
except errors.AmbiguousBase, e:
2193
m = ("sorry, bzr can't determine the right merge base yet\n"
2194
"candidates are:\n "
2195
+ "\n ".join(e.bases)
2196
+ "\n"
2197
"please specify an explicit base with -r,\n"
2198
"and (if you want) report this to the bzr developers\n")
2199
log_error(m)
2200
2201
# TODO: move up to common parent; this isn't merge-specific anymore.
2202
def _get_remembered_parent(self, tree, supplied_location, verb_string):
3861
2203
"""Use tree.branch's parent if none was supplied.
3862
2204
3863
2205
Report if the remembered location was used.
3864
2206
"""
3865
stored_location = tree.branch.get_submit_branch()
3866
stored_location_type = "submit"
3867
if stored_location is None:
3868
stored_location = tree.branch.get_parent()
3869
stored_location_type = "parent"
2207
if supplied_location is not None:
2208
return supplied_location
2209
stored_location = tree.branch.get_parent()
3870
2210
mutter("%s", stored_location)
3871
2211
if stored_location is None:
3872
raise errors.BzrCommandError("No location specified or remembered")
3873
display_url = urlutils.unescape_for_display(stored_location, 'utf-8')
3874
note(u"%s remembered %s location %s", verb_string,
3875
stored_location_type, display_url)
2212
raise BzrCommandError("No location specified or remembered")
2213
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2214
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
3876
2215
return stored_location
3877
2216
3878
2217
3880
2219
"""Redo a merge.
3881
2220
3882
2221
Use this if you want to try a different merge technique while resolving
3883
conflicts. Some merge techniques are better than others, and remerge
2222
conflicts. Some merge techniques are better than others, and remerge
3884
2223
lets you try different ones on different files.
3885
2224
3886
2225
The options for remerge have the same meaning and defaults as the ones for
3887
2226
merge. The difference is that remerge can (only) be run when there is a
3888
2227
pending merge, and it lets you specify particular files.
3889
2228
3890
:Examples:
2229
Examples:
2230
$ bzr remerge --show-base
3891
2231
Re-do the merge of all conflicted files, and show the base text in
3892
conflict regions, in addition to the usual THIS and OTHER texts::
3893
3894
bzr remerge --show-base
3895
2232
conflict regions, in addition to the usual THIS and OTHER texts.
2233
2234
$ bzr remerge --merge-type weave --reprocess foobar
3896
2235
Re-do the merge of "foobar", using the weave merge algorithm, with
3897
additional processing to reduce the size of conflict regions::
3898
3899
bzr remerge --merge-type weave --reprocess foobar
3900
"""
2236
additional processing to reduce the size of conflict regions.
2237
2238
The following merge types are available:"""
3901
2239
takes_args = ['file*']
3902
takes_options = [
3903
'merge-type',
3904
'reprocess',
3905
Option('show-base',
3906
help="Show base revision text in conflicts."),
3907
]
2240
takes_options = ['merge-type', 'reprocess',
2241
Option('show-base', help="Show base revision text in "
2242
"conflicts")]
2243
2244
def help(self):
2245
from merge import merge_type_help
2246
from inspect import getdoc
2247
return getdoc(self) + '\n' + merge_type_help()
3908
2248
3909
2249
def run(self, file_list=None, merge_type=None, show_base=False,
3910
2250
reprocess=False):
2251
from bzrlib.merge import merge_inner, transform_tree
3911
2252
if merge_type is None:
3912
merge_type = _mod_merge.Merge3Merger
2253
merge_type = Merge3Merger
3913
2254
tree, file_list = tree_files(file_list)
3914
2255
tree.lock_write()
3915
2256
try:
3916
parents = tree.get_parent_ids()
3917
if len(parents) != 2:
3918
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3919
" merges. Not cherrypicking or"
3920
" multi-merges.")
2257
pending_merges = tree.pending_merges()
2258
if len(pending_merges) != 1:
2259
raise BzrCommandError("Sorry, remerge only works after normal"
2260
" merges. Not cherrypicking or"
2261
" multi-merges.")
3921
2262
repository = tree.branch.repository
2263
base_revision = common_ancestor(tree.branch.last_revision(),
2264
pending_merges[0], repository)
2265
base_tree = repository.revision_tree(base_revision)
2266
other_tree = repository.revision_tree(pending_merges[0])
3922
2267
interesting_ids = None
3923
2268
new_conflicts = []
3924
2269
conflicts = tree.conflicts()
3927
2272
for filename in file_list:
3928
2273
file_id = tree.path2id(filename)
3929
2274
if file_id is None:
3930
raise errors.NotVersionedError(filename)
2275
raise NotVersionedError(filename)
3931
2276
interesting_ids.add(file_id)
3932
2277
if tree.kind(file_id) != "directory":
3933
2278
continue
3934
2279
3935
2280
for name, ie in tree.inventory.iter_entries(file_id):
3936
2281
interesting_ids.add(ie.file_id)
3937
2282
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3938
else:
3939
# Remerge only supports resolving contents conflicts
3940
allowed_conflicts = ('text conflict', 'contents conflict')
3941
restore_files = [c.path for c in conflicts
3942
if c.typestring in allowed_conflicts]
3943
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
2283
transform_tree(tree, tree.basis_tree(), interesting_ids)
3944
2284
tree.set_conflicts(ConflictList(new_conflicts))
3945
if file_list is not None:
2285
if file_list is None:
2286
restore_files = list(tree.iter_conflicts())
2287
else:
3946
2288
restore_files = file_list
3947
2289
for filename in restore_files:
3948
2290
try:
3949
2291
restore(tree.abspath(filename))
3950
except errors.NotConflicted:
2292
except NotConflicted:
3951
2293
pass
3952
# Disable pending merges, because the file texts we are remerging
3953
# have not had those merges performed. If we use the wrong parents
3954
# list, we imply that the working tree text has seen and rejected
3955
# all the changes from the other tree, when in fact those changes
3956
# have not yet been seen.
3957
pb = ui.ui_factory.nested_progress_bar()
3958
tree.set_parent_ids(parents[:1])
3959
try:
3960
merger = _mod_merge.Merger.from_revision_ids(pb,
3961
tree, parents[1])
3962
merger.interesting_ids = interesting_ids
3963
merger.merge_type = merge_type
3964
merger.show_base = show_base
3965
merger.reprocess = reprocess
3966
conflicts = merger.do_merge()
3967
finally:
3968
tree.set_parent_ids(parents)
3969
pb.finished()
2294
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2295
this_tree=tree,
2296
interesting_ids=interesting_ids,
2297
other_rev_id=pending_merges[0],
2298
merge_type=merge_type,
2299
show_base=show_base,
2300
reprocess=reprocess)
3970
2301
finally:
3971
2302
tree.unlock()
3972
2303
if conflicts > 0:
3974
2305
else:
3975
2306
return 0
3976
2307
3977
3978
2308
class cmd_revert(Command):
3979
"""Revert files to a previous revision.
3980
3981
Giving a list of files will revert only those files. Otherwise, all files
3982
will be reverted. If the revision is not specified with '--revision', the
3983
last committed revision is used.
3984
3985
To remove only some changes, without reverting to a prior version, use
3986
merge instead. For example, "merge . --revision -2..-3" will remove the
3987
changes introduced by -2, without affecting the changes introduced by -1.
3988
Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
3989
3990
By default, any files that have been manually changed will be backed up
3991
first. (Files changed only by merge are not backed up.) Backup files have
3992
'.~#~' appended to their name, where # is a number.
3993
3994
When you provide files, you can use their current pathname or the pathname
3995
from the target revision. So you can use revert to "undelete" a file by
3996
name. If you name a directory, all the contents of that directory will be
3997
reverted.
3998
3999
Any files that have been newly added since that revision will be deleted,
4000
with a backup kept if appropriate. Directories containing unknown files
4001
will not be deleted.
4002
4003
The working tree contains a list of pending merged revisions, which will
4004
be included as parents in the next commit. Normally, revert clears that
4005
list as well as reverting the files. If any files are specified, revert
4006
leaves the pending merge list alone and reverts only the files. Use "bzr
4007
revert ." in the tree root to revert all files but keep the merge record,
4008
and "bzr revert --forget-merges" to clear the pending merge list without
4009
reverting any files.
2309
"""Reverse all changes since the last commit.
2310
2311
Only versioned files are affected. Specify filenames to revert only
2312
those files. By default, any files that are changed will be backed up
2313
first. Backup files have a '~' appended to their name.
4010
2314
"""
4011
4012
_see_also = ['cat', 'export']
4013
takes_options = [
4014
'revision',
4015
Option('no-backup', "Do not save backups of reverted files."),
4016
Option('forget-merges',
4017
'Remove pending merge marker, without changing any files.'),
4018
]
2315
takes_options = ['revision', 'no-backup']
4019
2316
takes_args = ['file*']
2317
aliases = ['merge-revert']
4020
2318
4021
def run(self, revision=None, no_backup=False, file_list=None,
4022
forget_merges=None):
2319
def run(self, revision=None, no_backup=False, file_list=None):
2320
from bzrlib.commands import parse_spec
2321
if file_list is not None:
2322
if len(file_list) == 0:
2323
raise BzrCommandError("No files specified")
2324
else:
2325
file_list = []
2326
4023
2327
tree, file_list = tree_files(file_list)
4024
tree.lock_write()
4025
try:
4026
if forget_merges:
4027
tree.set_parent_ids(tree.get_parent_ids()[:1])
4028
else:
4029
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4030
finally:
4031
tree.unlock()
4032
4033
@staticmethod
4034
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4035
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
2328
if revision is None:
2329
# FIXME should be tree.last_revision
2330
rev_id = tree.last_revision()
2331
elif len(revision) != 1:
2332
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2333
else:
2334
rev_id = revision[0].in_history(tree.branch).rev_id
4036
2335
pb = ui.ui_factory.nested_progress_bar()
4037
2336
try:
4038
tree.revert(file_list, rev_tree, not no_backup, pb,
4039
report_changes=True)
2337
tree.revert(file_list,
2338
tree.branch.repository.revision_tree(rev_id),
2339
not no_backup, pb)
4040
2340
finally:
4041
2341
pb.finished()
4042
2342
4043
2343
4044
2344
class cmd_assert_fail(Command):
4045
2345
"""Test reporting of assertion failures"""
4046
# intended just for use in testing
4047
4048
2346
hidden = True
4049
4050
2347
def run(self):
4051
raise AssertionError("always fails")
2348
assert False, "always fails"
4052
2349
4053
2350
4054
2351
class cmd_help(Command):
4055
2352
"""Show help on a command or other topic.
4056
"""
4057
2353
4058
_see_also = ['topics']
4059
takes_options = [
4060
Option('long', 'Show help on all commands.'),
4061
]
2354
For a list of all available commands, say 'bzr help commands'."""
2355
takes_options = [Option('long', 'show help on all commands')]
4062
2356
takes_args = ['topic?']
4063
2357
aliases = ['?', '--help', '-?', '-h']
4064
2358
4065
2359
@display_command
4066
2360
def run(self, topic=None, long=False):
4067
import bzrlib.help
2361
import help
4068
2362
if topic is None and long:
4069
2363
topic = "commands"
4070
bzrlib.help.help(topic)
2364
help.help(topic)
4071
2365
4072
2366
4073
2367
class cmd_shell_complete(Command):
4074
2368
"""Show appropriate completions for context.
4075
2369
4076
For a list of all available commands, say 'bzr shell-complete'.
4077
"""
2370
For a list of all available commands, say 'bzr shell-complete'."""
4078
2371
takes_args = ['context?']
4079
2372
aliases = ['s-c']
4080
2373
hidden = True
4081
2374
4082
2375
@display_command
4083
2376
def run(self, context=None):
4084
2377
import shellcomplete
4085
2378
shellcomplete.shellcomplete(context)
4086
2379
4087
2380
2381
class cmd_fetch(Command):
2382
"""Copy in history from another branch but don't merge it.
2383
2384
This is an internal method used for pull and merge."""
2385
hidden = True
2386
takes_args = ['from_branch', 'to_branch']
2387
def run(self, from_branch, to_branch):
2388
from bzrlib.fetch import Fetcher
2389
from_b = Branch.open(from_branch)
2390
to_b = Branch.open(to_branch)
2391
Fetcher(to_b, from_b)
2392
2393
4088
2394
class cmd_missing(Command):
4089
2395
"""Show unmerged/unpulled revisions between two branches.
4090
2396
4091
OTHER_BRANCH may be local or remote.
4092
4093
To filter on a range of revisions, you can use the command -r begin..end
4094
-r revision requests a specific revision, -r ..end or -r begin.. are
4095
also valid.
4096
4097
:Examples:
4098
4099
Determine the missing revisions between this and the branch at the
4100
remembered pull location::
4101
4102
bzr missing
4103
4104
Determine the missing revisions between this and another branch::
4105
4106
bzr missing http://server/branch
4107
4108
Determine the missing revisions up to a specific revision on the other
4109
branch::
4110
4111
bzr missing -r ..-10
4112
4113
Determine the missing revisions up to a specific revision on this
4114
branch::
4115
4116
bzr missing --my-revision ..-10
4117
"""
4118
4119
_see_also = ['merge', 'pull']
2397
OTHER_BRANCH may be local or remote."""
4120
2398
takes_args = ['other_branch?']
4121
takes_options = [
4122
Option('reverse', 'Reverse the order of revisions.'),
4123
Option('mine-only',
4124
'Display changes in the local branch only.'),
4125
Option('this' , 'Same as --mine-only.'),
4126
Option('theirs-only',
4127
'Display changes in the remote branch only.'),
4128
Option('other', 'Same as --theirs-only.'),
4129
'log-format',
4130
'show-ids',
4131
'verbose',
4132
custom_help('revision',
4133
help='Filter on other branch revisions (inclusive). '
4134
'See "help revisionspec" for details.'),
4135
Option('my-revision',
4136
type=_parse_revision_str,
4137
help='Filter on local branch revisions (inclusive). '
4138
'See "help revisionspec" for details.'),
4139
Option('include-merges',
4140
'Show all revisions in addition to the mainline ones.'),
4141
]
2399
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2400
Option('mine-only',
2401
'Display changes in the local branch only'),
2402
Option('theirs-only',
2403
'Display changes in the remote branch only'),
2404
'log-format',
2405
'line',
2406
'long',
2407
'short',
2408
'show-ids',
2409
'verbose'
2410
]
4142
2411
encoding_type = 'replace'
4143
2412
4144
2413
@display_command
4145
2414
def run(self, other_branch=None, reverse=False, mine_only=False,
4146
theirs_only=False,
4147
log_format=None, long=False, short=False, line=False,
4148
show_ids=False, verbose=False, this=False, other=False,
4149
include_merges=False, revision=None, my_revision=None):
4150
from bzrlib.missing import find_unmerged, iter_log_revisions
4151
def message(s):
4152
if not is_quiet():
4153
self.outf.write(s)
4154
4155
if this:
4156
mine_only = this
4157
if other:
4158
theirs_only = other
4159
# TODO: We should probably check that we don't have mine-only and
4160
# theirs-only set, but it gets complicated because we also have
4161
# this and other which could be used.
4162
restrict = 'all'
4163
if mine_only:
4164
restrict = 'local'
4165
elif theirs_only:
4166
restrict = 'remote'
4167
2415
theirs_only=False, log_format=None, long=False, short=False, line=False,
2416
show_ids=False, verbose=False):
2417
from bzrlib.missing import find_unmerged, iter_log_data
2418
from bzrlib.log import log_formatter
4168
2419
local_branch = Branch.open_containing(u".")[0]
4169
2420
parent = local_branch.get_parent()
4170
2421
if other_branch is None:
4171
2422
other_branch = parent
4172
2423
if other_branch is None:
4173
raise errors.BzrCommandError("No peer location known"
4174
" or specified.")
4175
display_url = urlutils.unescape_for_display(parent,
4176
self.outf.encoding)
4177
message("Using saved parent location: "
4178
+ display_url + "\n")
4179
2424
raise BzrCommandError("No peer location known or specified.")
2425
print "Using last location: " + local_branch.get_parent()
4180
2426
remote_branch = Branch.open(other_branch)
4181
2427
if remote_branch.base == local_branch.base:
4182
2428
remote_branch = local_branch
4183
4184
local_revid_range = _revision_range_to_revid_range(
4185
_get_revision_range(my_revision, local_branch,
4186
self.name()))
4187
4188
remote_revid_range = _revision_range_to_revid_range(
4189
_get_revision_range(revision,
4190
remote_branch, self.name()))
4191
4192
2429
local_branch.lock_read()
4193
2430
try:
4194
2431
remote_branch.lock_read()
4195
2432
try:
4196
local_extra, remote_extra = find_unmerged(
4197
local_branch, remote_branch, restrict,
4198
backward=not reverse,
4199
include_merges=include_merges,
4200
local_revid_range=local_revid_range,
4201
remote_revid_range=remote_revid_range)
4202
4203
if log_format is None:
4204
registry = log.log_formatter_registry
4205
log_format = registry.get_default(local_branch)
4206
lf = log_format(to_file=self.outf,
4207
show_ids=show_ids,
4208
show_timezone='original')
4209
4210
status_code = 0
2433
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2434
if (log_format == None):
2435
default = local_branch.get_config().log_format()
2436
log_format = get_log_format(long=long, short=short,
2437
line=line, default=default)
2438
lf = log_formatter(log_format,
2439
to_file=self.outf,
2440
show_ids=show_ids,
2441
show_timezone='original')
2442
if reverse is False:
2443
local_extra.reverse()
2444
remote_extra.reverse()
4211
2445
if local_extra and not theirs_only:
4212
message("You have %d extra revision(s):\n" %
4213
len(local_extra))
4214
for revision in iter_log_revisions(local_extra,
4215
local_branch.repository,
4216
verbose):
4217
lf.log_revision(revision)
2446
print "You have %d extra revision(s):" % len(local_extra)
2447
for data in iter_log_data(local_extra, local_branch.repository,
2448
verbose):
2449
lf.show(*data)
4218
2450
printed_local = True
4219
status_code = 1
4220
2451
else:
4221
2452
printed_local = False
4222
4223
2453
if remote_extra and not mine_only:
4224
2454
if printed_local is True:
4225
message("\n\n\n")
4226
message("You are missing %d revision(s):\n" %
4227
len(remote_extra))
4228
for revision in iter_log_revisions(remote_extra,
4229
remote_branch.repository,
4230
verbose):
4231
lf.log_revision(revision)
2455
print "\n\n"
2456
print "You are missing %d revision(s):" % len(remote_extra)
2457
for data in iter_log_data(remote_extra, remote_branch.repository,
2458
verbose):
2459
lf.show(*data)
2460
if not remote_extra and not local_extra:
2461
status_code = 0
2462
print "Branches are up to date."
2463
else:
4232
2464
status_code = 1
4233
4234
if mine_only and not local_extra:
4235
# We checked local, and found nothing extra
4236
message('This branch is up to date.\n')
4237
elif theirs_only and not remote_extra:
4238
# We checked remote, and found nothing extra
4239
message('Other branch is up to date.\n')
4240
elif not (mine_only or theirs_only or local_extra or
4241
remote_extra):
4242
# We checked both branches, and neither one had extra
4243
# revisions
4244
message("Branches are up to date.\n")
4245
2465
finally:
4246
2466
remote_branch.unlock()
4247
2467
finally:
4257
2477
return status_code
4258
2478
4259
2479
4260
class cmd_pack(Command):
4261
"""Compress the data within a repository."""
4262
4263
_see_also = ['repositories']
4264
takes_args = ['branch_or_repo?']
4265
4266
def run(self, branch_or_repo='.'):
4267
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4268
try:
4269
branch = dir.open_branch()
4270
repository = branch.repository
4271
except errors.NotBranchError:
4272
repository = dir.open_repository()
4273
repository.pack()
4274
4275
4276
2480
class cmd_plugins(Command):
4277
"""List the installed plugins.
4278
4279
This command displays the list of installed plugins including
4280
version of plugin and a short description of each.
4281
4282
--verbose shows the path where each plugin is located.
4283
4284
A plugin is an external component for Bazaar that extends the
4285
revision control system, by adding or replacing code in Bazaar.
4286
Plugins can do a variety of things, including overriding commands,
4287
adding new commands, providing additional network transports and
4288
customizing log output.
4289
4290
See the Bazaar web site, http://bazaar-vcs.org, for further
4291
information on plugins including where to find them and how to
4292
install them. Instructions are also provided there on how to
4293
write new plugins using the Python programming language.
4294
"""
4295
takes_options = ['verbose']
4296
2481
"""List plugins"""
2482
hidden = True
4297
2483
@display_command
4298
def run(self, verbose=False):
2484
def run(self):
4299
2485
import bzrlib.plugin
4300
2486
from inspect import getdoc
4301
result = []
4302
for name, plugin in bzrlib.plugin.plugins().items():
4303
version = plugin.__version__
4304
if version == 'unknown':
4305
version = ''
4306
name_ver = '%s %s' % (name, version)
4307
d = getdoc(plugin.module)
2487
for name, plugin in bzrlib.plugin.all_plugins().items():
2488
if hasattr(plugin, '__path__'):
2489
print plugin.__path__[0]
2490
elif hasattr(plugin, '__file__'):
2491
print plugin.__file__
2492
else:
2493
print `plugin`
2494
2495
d = getdoc(plugin)
4308
2496
if d:
4309
doc = d.split('\n')[0]
4310
else:
4311
doc = '(no description)'
4312
result.append((name_ver, doc, plugin.path()))
4313
for name_ver, doc, path in sorted(result):
4314
print name_ver
4315
print ' ', doc
4316
if verbose:
4317
print ' ', path
4318
print
2497
print '\t', d.split('\n')[0]
4319
2498
4320
2499
4321
2500
class cmd_testament(Command):
4322
2501
"""Show testament (signing-form) of a revision."""
4323
takes_options = [
4324
'revision',
4325
Option('long', help='Produce long-format testament.'),
4326
Option('strict',
4327
help='Produce a strict-format testament.')]
2502
takes_options = ['revision', 'long',
2503
Option('strict', help='Produce a strict-format'
2504
' testament')]
4328
2505
takes_args = ['branch?']
4329
2506
@display_command
4330
2507
def run(self, branch=u'.', revision=None, long=False, strict=False):
4333
2510
testament_class = StrictTestament
4334
2511
else:
4335
2512
testament_class = Testament
4336
if branch == '.':
4337
b = Branch.open_containing(branch)[0]
4338
else:
4339
b = Branch.open(branch)
2513
b = WorkingTree.open_containing(branch)[0].branch
4340
2514
b.lock_read()
4341
2515
try:
4342
2516
if revision is None:
4343
2517
rev_id = b.last_revision()
4344
2518
else:
4345
rev_id = revision[0].as_revision_id(b)
2519
rev_id = revision[0].in_history(b).rev_id
4346
2520
t = testament_class.from_revision(b.repository, rev_id)
4347
2521
if long:
4348
2522
sys.stdout.writelines(t.as_text_lines())
4358
2532
This prints out the given file with an annotation on the left side
4359
2533
indicating which revision, author and date introduced the change.
4360
2534
4361
If the origin is the same for a run of consecutive lines, it is
2535
If the origin is the same for a run of consecutive lines, it is
4362
2536
shown only at the top, unless the --all option is given.
4363
2537
"""
4364
2538
# TODO: annotate directories; showing when each file was last changed
4365
# TODO: if the working copy is modified, show annotations on that
2539
# TODO: if the working copy is modified, show annotations on that
4366
2540
# with new uncommitted lines marked
4367
2541
aliases = ['ann', 'blame', 'praise']
4368
2542
takes_args = ['filename']
4369
takes_options = [Option('all', help='Show annotations on all lines.'),
4370
Option('long', help='Show commit date in annotations.'),
4371
'revision',
4372
'show-ids',
2543
takes_options = [Option('all', help='show annotations on all lines'),
2544
Option('long', help='show date in annotations'),
2545
'revision'
4373
2546
]
4374
encoding_type = 'exact'
4375
2547
4376
2548
@display_command
4377
def run(self, filename, all=False, long=False, revision=None,
4378
show_ids=False):
4379
from bzrlib.annotate import annotate_file, annotate_file_tree
4380
wt, branch, relpath = \
4381
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4382
if wt is not None:
4383
wt.lock_read()
4384
else:
4385
branch.lock_read()
2549
def run(self, filename, all=False, long=False, revision=None):
2550
from bzrlib.annotate import annotate_file
2551
tree, relpath = WorkingTree.open_containing(filename)
2552
branch = tree.branch
2553
branch.lock_read()
4386
2554
try:
4387
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4388
if wt is not None:
4389
file_id = wt.path2id(relpath)
2555
if revision is None:
2556
revision_id = branch.last_revision()
2557
elif len(revision) != 1:
2558
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
4390
2559
else:
4391
file_id = tree.path2id(relpath)
4392
if file_id is None:
4393
raise errors.NotVersionedError(filename)
2560
revision_id = revision[0].in_history(branch).rev_id
2561
file_id = tree.inventory.path2id(relpath)
2562
tree = branch.repository.revision_tree(revision_id)
4394
2563
file_version = tree.inventory[file_id].revision
4395
if wt is not None and revision is None:
4396
# If there is a tree and we're not annotating historical
4397
# versions, annotate the working tree's content.
4398
annotate_file_tree(wt, file_id, self.outf, long, all,
4399
show_ids=show_ids)
4400
else:
4401
annotate_file(branch, file_version, file_id, long, all, self.outf,
4402
show_ids=show_ids)
2564
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
4403
2565
finally:
4404
if wt is not None:
4405
wt.unlock()
4406
else:
4407
branch.unlock()
2566
branch.unlock()
4408
2567
4409
2568
4410
2569
class cmd_re_sign(Command):
4414
2573
hidden = True # is this right ?
4415
2574
takes_args = ['revision_id*']
4416
2575
takes_options = ['revision']
4417
2576
4418
2577
def run(self, revision_id_list=None, revision=None):
2578
import bzrlib.gpg as gpg
4419
2579
if revision_id_list is not None and revision is not None:
4420
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
2580
raise BzrCommandError('You can only supply one of revision_id or --revision')
4421
2581
if revision_id_list is None and revision is None:
4422
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
2582
raise BzrCommandError('You must supply either --revision or a revision_id')
4423
2583
b = WorkingTree.open_containing(u'.')[0].branch
4424
b.lock_write()
4425
try:
4426
return self._run(b, revision_id_list, revision)
4427
finally:
4428
b.unlock()
4429
4430
def _run(self, b, revision_id_list, revision):
4431
import bzrlib.gpg as gpg
4432
2584
gpg_strategy = gpg.GPGStrategy(b.get_config())
4433
2585
if revision_id_list is not None:
4434
b.repository.start_write_group()
4435
try:
4436
for revision_id in revision_id_list:
4437
b.repository.sign_revision(revision_id, gpg_strategy)
4438
except:
4439
b.repository.abort_write_group()
4440
raise
4441
else:
4442
b.repository.commit_write_group()
2586
for revision_id in revision_id_list:
2587
b.repository.sign_revision(revision_id, gpg_strategy)
4443
2588
elif revision is not None:
4444
2589
if len(revision) == 1:
4445
2590
revno, rev_id = revision[0].in_history(b)
4446
b.repository.start_write_group()
4447
try:
4448
b.repository.sign_revision(rev_id, gpg_strategy)
4449
except:
4450
b.repository.abort_write_group()
4451
raise
4452
else:
4453
b.repository.commit_write_group()
2591
b.repository.sign_revision(rev_id, gpg_strategy)
4454
2592
elif len(revision) == 2:
4455
2593
# are they both on rh- if so we can walk between them
4456
2594
# might be nice to have a range helper for arbitrary
4460
2598
if to_revid is None:
4461
2599
to_revno = b.revno()
4462
2600
if from_revno is None or to_revno is None:
4463
raise errors.BzrCommandError('Cannot sign a range of non-revision-history revisions')
4464
b.repository.start_write_group()
4465
try:
4466
for revno in range(from_revno, to_revno + 1):
4467
b.repository.sign_revision(b.get_rev_id(revno),
4468
gpg_strategy)
4469
except:
4470
b.repository.abort_write_group()
4471
raise
4472
else:
4473
b.repository.commit_write_group()
2601
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2602
for revno in range(from_revno, to_revno + 1):
2603
b.repository.sign_revision(b.get_rev_id(revno),
2604
gpg_strategy)
4474
2605
else:
4475
raise errors.BzrCommandError('Please supply either one revision, or a range.')
2606
raise BzrCommandError('Please supply either one revision, or a range.')
4476
2607
4477
2608
4478
2609
class cmd_bind(Command):
4479
"""Convert the current branch into a checkout of the supplied branch.
4480
4481
Once converted into a checkout, commits must succeed on the master branch
4482
before they will be applied to the local branch.
4483
4484
Bound branches use the nickname of its master branch unless it is set
4485
locally, in which case binding will update the the local nickname to be
4486
that of the master.
2610
"""Bind the current branch to a master branch.
2611
2612
After binding, commits must succeed on the master branch
2613
before they are executed on the local one.
4487
2614
"""
4488
2615
4489
_see_also = ['checkouts', 'unbind']
4490
takes_args = ['location?']
2616
takes_args = ['location']
4491
2617
takes_options = []
4492
2618
4493
2619
def run(self, location=None):
4494
2620
b, relpath = Branch.open_containing(u'.')
4495
if location is None:
4496
try:
4497
location = b.get_old_bound_location()
4498
except errors.UpgradeRequired:
4499
raise errors.BzrCommandError('No location supplied. '
4500
'This format does not remember old locations.')
4501
else:
4502
if location is None:
4503
raise errors.BzrCommandError('No location supplied and no '
4504
'previous location known')
4505
2621
b_other = Branch.open(location)
4506
2622
try:
4507
2623
b.bind(b_other)
4508
except errors.DivergedBranches:
4509
raise errors.BzrCommandError('These branches have diverged.'
4510
' Try merging, and then bind again.')
4511
if b.get_config().has_explicit_nickname():
4512
b.nick = b_other.nick
2624
except DivergedBranches:
2625
raise BzrCommandError('These branches have diverged.'
2626
' Try merging, and then bind again.')
4513
2627
4514
2628
4515
2629
class cmd_unbind(Command):
4516
"""Convert the current checkout into a regular branch.
2630
"""Unbind the current branch from its master branch.
4517
2631
4518
After unbinding, the local branch is considered independent and subsequent
4519
commits will be local only.
2632
After unbinding, the local branch is considered independent.
2633
All subsequent commits will be local.
4520
2634
"""
4521
2635
4522
_see_also = ['checkouts', 'bind']
4523
2636
takes_args = []
4524
2637
takes_options = []
4525
2638
4526
2639
def run(self):
4527
2640
b, relpath = Branch.open_containing(u'.')
4528
2641
if not b.unbind():
4529
raise errors.BzrCommandError('Local branch is not bound')
2642
raise BzrCommandError('Local branch is not bound')
4530
2643
4531
2644
4532
2645
class cmd_uncommit(Command):
4535
2648
--verbose will print out what is being removed.
4536
2649
--dry-run will go through all the motions, but not actually
4537
2650
remove anything.
4538
4539
If --revision is specified, uncommit revisions to leave the branch at the
4540
specified revision. For example, "bzr uncommit -r 15" will leave the
4541
branch at revision 15.
4542
4543
Uncommit leaves the working tree ready for a new commit. The only change
4544
it may make is to restore any pending merges that were present before
4545
the commit.
2651
2652
In the future, uncommit will create a revision bundle, which can then
2653
be re-applied.
4546
2654
"""
4547
2655
4548
2656
# TODO: jam 20060108 Add an option to allow uncommit to remove
4549
2657
# unreferenced information in 'branch-as-repository' branches.
4550
2658
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
4551
2659
# information in shared branches as well.
4552
_see_also = ['commit']
4553
2660
takes_options = ['verbose', 'revision',
4554
Option('dry-run', help='Don\'t actually make changes.'),
4555
Option('force', help='Say yes to all questions.'),
4556
Option('local',
4557
help="Only remove the commits from the local branch"
4558
" when in a checkout."
4559
),
4560
]
2661
Option('dry-run', help='Don\'t actually make changes'),
2662
Option('force', help='Say yes to all questions.')]
4561
2663
takes_args = ['location?']
4562
2664
aliases = []
4563
encoding_type = 'replace'
4564
2665
4565
2666
def run(self, location=None,
4566
2667
dry_run=False, verbose=False,
4567
revision=None, force=False, local=False):
2668
revision=None, force=False):
2669
from bzrlib.log import log_formatter, show_log
2670
import sys
2671
from bzrlib.uncommit import uncommit
2672
4568
2673
if location is None:
4569
2674
location = u'.'
4570
2675
control, relpath = bzrdir.BzrDir.open_containing(location)
4575
2680
tree = None
4576
2681
b = control.open_branch()
4577
2682
4578
if tree is not None:
4579
tree.lock_write()
4580
else:
4581
b.lock_write()
4582
try:
4583
return self._run(b, tree, dry_run, verbose, revision, force,
4584
local=local)
4585
finally:
4586
if tree is not None:
4587
tree.unlock()
4588
else:
4589
b.unlock()
4590
4591
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4592
from bzrlib.log import log_formatter, show_log
4593
from bzrlib.uncommit import uncommit
4594
4595
last_revno, last_rev_id = b.last_revision_info()
4596
4597
2683
rev_id = None
4598
2684
if revision is None:
4599
revno = last_revno
4600
rev_id = last_rev_id
2685
revno = b.revno()
4601
2686
else:
4602
2687
# 'bzr uncommit -r 10' actually means uncommit
4603
2688
# so that the final tree is at revno 10.
4604
2689
# but bzrlib.uncommit.uncommit() actually uncommits
4605
2690
# the revisions that are supplied.
4606
2691
# So we need to offset it by one
4607
revno = revision[0].in_history(b).revno + 1
4608
if revno <= last_revno:
4609
rev_id = b.get_rev_id(revno)
2692
revno = revision[0].in_history(b).revno+1
4610
2693
4611
if rev_id is None or _mod_revision.is_null(rev_id):
2694
if revno <= b.revno():
2695
rev_id = b.get_rev_id(revno)
2696
if rev_id is None:
4612
2697
self.outf.write('No revisions to uncommit.\n')
4613
2698
return 1
4614
2699
4621
2706
verbose=False,
4622
2707
direction='forward',
4623
2708
start_revision=revno,
4624
end_revision=last_revno)
2709
end_revision=b.revno())
4625
2710
4626
2711
if dry_run:
4627
2712
print 'Dry-run, pretending to remove the above revisions.'
4635
2720
print 'Canceled'
4636
2721
return 0
4637
2722
4638
mutter('Uncommitting from {%s} to {%s}',
4639
last_rev_id, rev_id)
4640
2723
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4641
revno=revno, local=local)
4642
note('You can restore the old tip by running:\n'
4643
' bzr pull . -r revid:%s', last_rev_id)
2724
revno=revno)
4644
2725
4645
2726
4646
2727
class cmd_break_lock(Command):
4650
2731
holding the lock has been stopped.
4651
2732
4652
2733
You can get information on what locks are open via the 'bzr info' command.
4653
4654
:Examples:
2734
2735
example:
4655
2736
bzr break-lock
4656
2737
"""
4657
2738
takes_args = ['location?']
4664
2745
control.break_lock()
4665
2746
except NotImplementedError:
4666
2747
pass
4667
4668
4669
class cmd_wait_until_signalled(Command):
4670
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4671
4672
This just prints a line to signal when it is ready, then blocks on stdin.
4673
"""
4674
4675
hidden = True
4676
4677
def run(self):
4678
sys.stdout.write("running\n")
4679
sys.stdout.flush()
4680
sys.stdin.readline()
4681
4682
4683
class cmd_serve(Command):
4684
"""Run the bzr server."""
4685
4686
aliases = ['server']
4687
4688
takes_options = [
4689
Option('inet',
4690
help='Serve on stdin/out for use from inetd or sshd.'),
4691
RegistryOption('protocol',
4692
help="Protocol to serve.",
4693
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4694
value_switches=True),
4695
Option('port',
4696
help='Listen for connections on nominated port of the form '
4697
'[hostname:]portnumber. Passing 0 as the port number will '
4698
'result in a dynamically allocated port. The default port '
4699
'depends on the protocol.',
4700
type=str),
4701
Option('directory',
4702
help='Serve contents of this directory.',
4703
type=unicode),
4704
Option('allow-writes',
4705
help='By default the server is a readonly server. Supplying '
4706
'--allow-writes enables write access to the contents of '
4707
'the served directory and below.'
4708
),
4709
]
4710
4711
def get_host_and_port(self, port):
4712
"""Return the host and port to run the smart server on.
4713
4714
If 'port' is None, None will be returned for the host and port.
4715
4716
If 'port' has a colon in it, the string before the colon will be
4717
interpreted as the host.
4718
4719
:param port: A string of the port to run the server on.
4720
:return: A tuple of (host, port), where 'host' is a host name or IP,
4721
and port is an integer TCP/IP port.
4722
"""
4723
host = None
4724
if port is not None:
4725
if ':' in port:
4726
host, port = port.split(':')
4727
port = int(port)
4728
return host, port
4729
4730
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4731
protocol=None):
4732
from bzrlib.transport import get_transport, transport_server_registry
4733
if directory is None:
4734
directory = os.getcwd()
4735
if protocol is None:
4736
protocol = transport_server_registry.get()
4737
host, port = self.get_host_and_port(port)
4738
url = urlutils.local_path_to_url(directory)
4739
if not allow_writes:
4740
url = 'readonly+' + url
4741
transport = get_transport(url)
4742
protocol(transport, host, port, inet)
4743
4744
4745
class cmd_join(Command):
4746
"""Combine a tree into its containing tree.
4747
4748
This command requires the target tree to be in a rich-root format.
4749
4750
The TREE argument should be an independent tree, inside another tree, but
4751
not part of it. (Such trees can be produced by "bzr split", but also by
4752
running "bzr branch" with the target inside a tree.)
4753
4754
The result is a combined tree, with the subtree no longer an independant
4755
part. This is marked as a merge of the subtree into the containing tree,
4756
and all history is preserved.
4757
"""
4758
4759
_see_also = ['split']
4760
takes_args = ['tree']
4761
takes_options = [
4762
Option('reference', help='Join by reference.', hidden=True),
4763
]
4764
4765
def run(self, tree, reference=False):
4766
sub_tree = WorkingTree.open(tree)
4767
parent_dir = osutils.dirname(sub_tree.basedir)
4768
containing_tree = WorkingTree.open_containing(parent_dir)[0]
4769
repo = containing_tree.branch.repository
4770
if not repo.supports_rich_root():
4771
raise errors.BzrCommandError(
4772
"Can't join trees because %s doesn't support rich root data.\n"
4773
"You can use bzr upgrade on the repository."
4774
% (repo,))
4775
if reference:
4776
try:
4777
containing_tree.add_reference(sub_tree)
4778
except errors.BadReferenceTarget, e:
4779
# XXX: Would be better to just raise a nicely printable
4780
# exception from the real origin. Also below. mbp 20070306
4781
raise errors.BzrCommandError("Cannot join %s. %s" %
4782
(tree, e.reason))
4783
else:
4784
try:
4785
containing_tree.subsume(sub_tree)
4786
except errors.BadSubsumeSource, e:
4787
raise errors.BzrCommandError("Cannot join %s. %s" %
4788
(tree, e.reason))
4789
4790
4791
class cmd_split(Command):
4792
"""Split a subdirectory of a tree into a separate tree.
4793
4794
This command will produce a target tree in a format that supports
4795
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4796
converted into earlier formats like 'dirstate-tags'.
4797
4798
The TREE argument should be a subdirectory of a working tree. That
4799
subdirectory will be converted into an independent tree, with its own
4800
branch. Commits in the top-level tree will not apply to the new subtree.
4801
"""
4802
4803
_see_also = ['join']
4804
takes_args = ['tree']
4805
4806
def run(self, tree):
4807
containing_tree, subdir = WorkingTree.open_containing(tree)
4808
sub_id = containing_tree.path2id(subdir)
4809
if sub_id is None:
4810
raise errors.NotVersionedError(subdir)
4811
try:
4812
containing_tree.extract(sub_id)
4813
except errors.RootNotRich:
4814
raise errors.RichRootUpgradeRequired(containing_tree.branch.base)
4815
4816
4817
class cmd_merge_directive(Command):
4818
"""Generate a merge directive for auto-merge tools.
4819
4820
A directive requests a merge to be performed, and also provides all the
4821
information necessary to do so. This means it must either include a
4822
revision bundle, or the location of a branch containing the desired
4823
revision.
4824
4825
A submit branch (the location to merge into) must be supplied the first
4826
time the command is issued. After it has been supplied once, it will
4827
be remembered as the default.
4828
4829
A public branch is optional if a revision bundle is supplied, but required
4830
if --diff or --plain is specified. It will be remembered as the default
4831
after the first use.
4832
"""
4833
4834
takes_args = ['submit_branch?', 'public_branch?']
4835
4836
hidden = True
4837
4838
_see_also = ['send']
4839
4840
takes_options = [
4841
RegistryOption.from_kwargs('patch-type',
4842
'The type of patch to include in the directive.',
4843
title='Patch type',
4844
value_switches=True,
4845
enum_switch=False,
4846
bundle='Bazaar revision bundle (default).',
4847
diff='Normal unified diff.',
4848
plain='No patch, just directive.'),
4849
Option('sign', help='GPG-sign the directive.'), 'revision',
4850
Option('mail-to', type=str,
4851
help='Instead of printing the directive, email to this address.'),
4852
Option('message', type=str, short_name='m',
4853
help='Message to use when committing this merge.')
4854
]
4855
4856
encoding_type = 'exact'
4857
4858
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4859
sign=False, revision=None, mail_to=None, message=None):
4860
from bzrlib.revision import ensure_null, NULL_REVISION
4861
include_patch, include_bundle = {
4862
'plain': (False, False),
4863
'diff': (True, False),
4864
'bundle': (True, True),
4865
}[patch_type]
4866
branch = Branch.open('.')
4867
stored_submit_branch = branch.get_submit_branch()
4868
if submit_branch is None:
4869
submit_branch = stored_submit_branch
4870
else:
4871
if stored_submit_branch is None:
4872
branch.set_submit_branch(submit_branch)
4873
if submit_branch is None:
4874
submit_branch = branch.get_parent()
4875
if submit_branch is None:
4876
raise errors.BzrCommandError('No submit branch specified or known')
4877
4878
stored_public_branch = branch.get_public_branch()
4879
if public_branch is None:
4880
public_branch = stored_public_branch
4881
elif stored_public_branch is None:
4882
branch.set_public_branch(public_branch)
4883
if not include_bundle and public_branch is None:
4884
raise errors.BzrCommandError('No public branch specified or'
4885
' known')
4886
base_revision_id = None
4887
if revision is not None:
4888
if len(revision) > 2:
4889
raise errors.BzrCommandError('bzr merge-directive takes '
4890
'at most two one revision identifiers')
4891
revision_id = revision[-1].as_revision_id(branch)
4892
if len(revision) == 2:
4893
base_revision_id = revision[0].as_revision_id(branch)
4894
else:
4895
revision_id = branch.last_revision()
4896
revision_id = ensure_null(revision_id)
4897
if revision_id == NULL_REVISION:
4898
raise errors.BzrCommandError('No revisions to bundle.')
4899
directive = merge_directive.MergeDirective2.from_objects(
4900
branch.repository, revision_id, time.time(),
4901
osutils.local_time_offset(), submit_branch,
4902
public_branch=public_branch, include_patch=include_patch,
4903
include_bundle=include_bundle, message=message,
4904
base_revision_id=base_revision_id)
4905
if mail_to is None:
4906
if sign:
4907
self.outf.write(directive.to_signed(branch))
4908
else:
4909
self.outf.writelines(directive.to_lines())
4910
else:
4911
message = directive.to_email(mail_to, branch, sign)
4912
s = SMTPConnection(branch.get_config())
4913
s.send_email(message)
4914
4915
4916
class cmd_send(Command):
4917
"""Mail or create a merge-directive for submitting changes.
4918
4919
A merge directive provides many things needed for requesting merges:
4920
4921
* A machine-readable description of the merge to perform
4922
4923
* An optional patch that is a preview of the changes requested
4924
4925
* An optional bundle of revision data, so that the changes can be applied
4926
directly from the merge directive, without retrieving data from a
4927
branch.
4928
4929
If --no-bundle is specified, then public_branch is needed (and must be
4930
up-to-date), so that the receiver can perform the merge using the
4931
public_branch. The public_branch is always included if known, so that
4932
people can check it later.
4933
4934
The submit branch defaults to the parent, but can be overridden. Both
4935
submit branch and public branch will be remembered if supplied.
4936
4937
If a public_branch is known for the submit_branch, that public submit
4938
branch is used in the merge instructions. This means that a local mirror
4939
can be used as your actual submit branch, once you have set public_branch
4940
for that mirror.
4941
4942
Mail is sent using your preferred mail program. This should be transparent
4943
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
4944
If the preferred client can't be found (or used), your editor will be used.
4945
4946
To use a specific mail program, set the mail_client configuration option.
4947
(For Thunderbird 1.5, this works around some bugs.) Supported values for
4948
specific clients are "claws", "evolution", "kmail", "mutt", and
4949
"thunderbird"; generic options are "default", "editor", "emacsclient",
4950
"mapi", and "xdg-email". Plugins may also add supported clients.
4951
4952
If mail is being sent, a to address is required. This can be supplied
4953
either on the commandline, by setting the submit_to configuration
4954
option in the branch itself or the child_submit_to configuration option
4955
in the submit branch.
4956
4957
Two formats are currently supported: "4" uses revision bundle format 4 and
4958
merge directive format 2. It is significantly faster and smaller than
4959
older formats. It is compatible with Bazaar 0.19 and later. It is the
4960
default. "0.9" uses revision bundle format 0.9 and merge directive
4961
format 1. It is compatible with Bazaar 0.12 - 0.18.
4962
4963
The merge directives created by bzr send may be applied using bzr merge or
4964
bzr pull by specifying a file containing a merge directive as the location.
4965
"""
4966
4967
encoding_type = 'exact'
4968
4969
_see_also = ['merge', 'pull']
4970
4971
takes_args = ['submit_branch?', 'public_branch?']
4972
4973
takes_options = [
4974
Option('no-bundle',
4975
help='Do not include a bundle in the merge directive.'),
4976
Option('no-patch', help='Do not include a preview patch in the merge'
4977
' directive.'),
4978
Option('remember',
4979
help='Remember submit and public branch.'),
4980
Option('from',
4981
help='Branch to generate the submission from, '
4982
'rather than the one containing the working directory.',
4983
short_name='f',
4984
type=unicode),
4985
Option('output', short_name='o',
4986
help='Write merge directive to this file; '
4987
'use - for stdout.',
4988
type=unicode),
4989
Option('strict',
4990
help='Refuse to send if there are uncommitted changes in'
4991
' the working tree, --no-strict disables the check.'),
4992
Option('mail-to', help='Mail the request to this address.',
4993
type=unicode),
4994
'revision',
4995
'message',
4996
Option('body', help='Body for the email.', type=unicode),
4997
RegistryOption('format',
4998
help='Use the specified output format.',
4999
lazy_registry=('bzrlib.send', 'format_registry')),
5000
]
5001
5002
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5003
no_patch=False, revision=None, remember=False, output=None,
5004
format=None, mail_to=None, message=None, body=None,
5005
strict=None, **kwargs):
5006
from bzrlib.send import send
5007
return send(submit_branch, revision, public_branch, remember,
5008
format, no_bundle, no_patch, output,
5009
kwargs.get('from', '.'), mail_to, message, body,
5010
self.outf,
5011
strict=strict)
5012
5013
5014
class cmd_bundle_revisions(cmd_send):
5015
"""Create a merge-directive for submitting changes.
5016
5017
A merge directive provides many things needed for requesting merges:
5018
5019
* A machine-readable description of the merge to perform
5020
5021
* An optional patch that is a preview of the changes requested
5022
5023
* An optional bundle of revision data, so that the changes can be applied
5024
directly from the merge directive, without retrieving data from a
5025
branch.
5026
5027
If --no-bundle is specified, then public_branch is needed (and must be
5028
up-to-date), so that the receiver can perform the merge using the
5029
public_branch. The public_branch is always included if known, so that
5030
people can check it later.
5031
5032
The submit branch defaults to the parent, but can be overridden. Both
5033
submit branch and public branch will be remembered if supplied.
5034
5035
If a public_branch is known for the submit_branch, that public submit
5036
branch is used in the merge instructions. This means that a local mirror
5037
can be used as your actual submit branch, once you have set public_branch
5038
for that mirror.
5039
5040
Two formats are currently supported: "4" uses revision bundle format 4 and
5041
merge directive format 2. It is significantly faster and smaller than
5042
older formats. It is compatible with Bazaar 0.19 and later. It is the
5043
default. "0.9" uses revision bundle format 0.9 and merge directive
5044
format 1. It is compatible with Bazaar 0.12 - 0.18.
5045
"""
5046
5047
takes_options = [
5048
Option('no-bundle',
5049
help='Do not include a bundle in the merge directive.'),
5050
Option('no-patch', help='Do not include a preview patch in the merge'
5051
' directive.'),
5052
Option('remember',
5053
help='Remember submit and public branch.'),
5054
Option('from',
5055
help='Branch to generate the submission from, '
5056
'rather than the one containing the working directory.',
5057
short_name='f',
5058
type=unicode),
5059
Option('output', short_name='o', help='Write directive to this file.',
5060
type=unicode),
5061
Option('strict',
5062
help='Refuse to bundle revisions if there are uncommitted'
5063
' changes in the working tree, --no-strict disables the check.'),
5064
'revision',
5065
RegistryOption('format',
5066
help='Use the specified output format.',
5067
lazy_registry=('bzrlib.send', 'format_registry')),
5068
]
5069
aliases = ['bundle']
5070
5071
_see_also = ['send', 'merge']
5072
5073
hidden = True
5074
5075
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5076
no_patch=False, revision=None, remember=False, output=None,
5077
format=None, strict=None, **kwargs):
5078
if output is None:
5079
output = '-'
5080
from bzrlib.send import send
5081
return send(submit_branch, revision, public_branch, remember,
5082
format, no_bundle, no_patch, output,
5083
kwargs.get('from', '.'), None, None, None,
5084
self.outf, strict=strict)
5085
5086
5087
class cmd_tag(Command):
5088
"""Create, remove or modify a tag naming a revision.
5089
5090
Tags give human-meaningful names to revisions. Commands that take a -r
5091
(--revision) option can be given -rtag:X, where X is any previously
5092
created tag.
5093
5094
Tags are stored in the branch. Tags are copied from one branch to another
5095
along when you branch, push, pull or merge.
5096
5097
It is an error to give a tag name that already exists unless you pass
5098
--force, in which case the tag is moved to point to the new revision.
5099
5100
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5101
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5102
"""
5103
5104
_see_also = ['commit', 'tags']
5105
takes_args = ['tag_name']
5106
takes_options = [
5107
Option('delete',
5108
help='Delete this tag rather than placing it.',
5109
),
5110
Option('directory',
5111
help='Branch in which to place the tag.',
5112
short_name='d',
5113
type=unicode,
5114
),
5115
Option('force',
5116
help='Replace existing tags.',
5117
),
5118
'revision',
5119
]
5120
5121
def run(self, tag_name,
5122
delete=None,
5123
directory='.',
5124
force=None,
5125
revision=None,
5126
):
5127
branch, relpath = Branch.open_containing(directory)
5128
branch.lock_write()
5129
try:
5130
if delete:
5131
branch.tags.delete_tag(tag_name)
5132
self.outf.write('Deleted tag %s.\n' % tag_name)
5133
else:
5134
if revision:
5135
if len(revision) != 1:
5136
raise errors.BzrCommandError(
5137
"Tags can only be placed on a single revision, "
5138
"not on a range")
5139
revision_id = revision[0].as_revision_id(branch)
5140
else:
5141
revision_id = branch.last_revision()
5142
if (not force) and branch.tags.has_tag(tag_name):
5143
raise errors.TagAlreadyExists(tag_name)
5144
branch.tags.set_tag(tag_name, revision_id)
5145
self.outf.write('Created tag %s.\n' % tag_name)
5146
finally:
5147
branch.unlock()
5148
5149
5150
class cmd_tags(Command):
5151
"""List tags.
5152
5153
This command shows a table of tag names and the revisions they reference.
5154
"""
5155
5156
_see_also = ['tag']
5157
takes_options = [
5158
Option('directory',
5159
help='Branch whose tags should be displayed.',
5160
short_name='d',
5161
type=unicode,
5162
),
5163
RegistryOption.from_kwargs('sort',
5164
'Sort tags by different criteria.', title='Sorting',
5165
alpha='Sort tags lexicographically (default).',
5166
time='Sort tags chronologically.',
5167
),
5168
'show-ids',
5169
'revision',
5170
]
5171
5172
@display_command
5173
def run(self,
5174
directory='.',
5175
sort='alpha',
5176
show_ids=False,
5177
revision=None,
5178
):
5179
branch, relpath = Branch.open_containing(directory)
5180
5181
tags = branch.tags.get_tag_dict().items()
5182
if not tags:
5183
return
5184
5185
branch.lock_read()
5186
try:
5187
if revision:
5188
graph = branch.repository.get_graph()
5189
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5190
revid1, revid2 = rev1.rev_id, rev2.rev_id
5191
# only show revisions between revid1 and revid2 (inclusive)
5192
tags = [(tag, revid) for tag, revid in tags if
5193
graph.is_between(revid, revid1, revid2)]
5194
if sort == 'alpha':
5195
tags.sort()
5196
elif sort == 'time':
5197
timestamps = {}
5198
for tag, revid in tags:
5199
try:
5200
revobj = branch.repository.get_revision(revid)
5201
except errors.NoSuchRevision:
5202
timestamp = sys.maxint # place them at the end
5203
else:
5204
timestamp = revobj.timestamp
5205
timestamps[revid] = timestamp
5206
tags.sort(key=lambda x: timestamps[x[1]])
5207
if not show_ids:
5208
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5209
for index, (tag, revid) in enumerate(tags):
5210
try:
5211
revno = branch.revision_id_to_dotted_revno(revid)
5212
if isinstance(revno, tuple):
5213
revno = '.'.join(map(str, revno))
5214
except errors.NoSuchRevision:
5215
# Bad tag data/merges can lead to tagged revisions
5216
# which are not in this branch. Fail gracefully ...
5217
revno = '?'
5218
tags[index] = (tag, revno)
5219
finally:
5220
branch.unlock()
5221
for tag, revspec in tags:
5222
self.outf.write('%-20s %s\n' % (tag, revspec))
5223
5224
5225
class cmd_reconfigure(Command):
5226
"""Reconfigure the type of a bzr directory.
5227
5228
A target configuration must be specified.
5229
5230
For checkouts, the bind-to location will be auto-detected if not specified.
5231
The order of preference is
5232
1. For a lightweight checkout, the current bound location.
5233
2. For branches that used to be checkouts, the previously-bound location.
5234
3. The push location.
5235
4. The parent location.
5236
If none of these is available, --bind-to must be specified.
5237
"""
5238
5239
_see_also = ['branches', 'checkouts', 'standalone-trees', 'working-trees']
5240
takes_args = ['location?']
5241
takes_options = [
5242
RegistryOption.from_kwargs(
5243
'target_type',
5244
title='Target type',
5245
help='The type to reconfigure the directory to.',
5246
value_switches=True, enum_switch=False,
5247
branch='Reconfigure to be an unbound branch with no working tree.',
5248
tree='Reconfigure to be an unbound branch with a working tree.',
5249
checkout='Reconfigure to be a bound branch with a working tree.',
5250
lightweight_checkout='Reconfigure to be a lightweight'
5251
' checkout (with no local history).',
5252
standalone='Reconfigure to be a standalone branch '
5253
'(i.e. stop using shared repository).',
5254
use_shared='Reconfigure to use a shared repository.',
5255
with_trees='Reconfigure repository to create '
5256
'working trees on branches by default.',
5257
with_no_trees='Reconfigure repository to not create '
5258
'working trees on branches by default.'
5259
),
5260
Option('bind-to', help='Branch to bind checkout to.', type=str),
5261
Option('force',
5262
help='Perform reconfiguration even if local changes'
5263
' will be lost.')
5264
]
5265
5266
def run(self, location=None, target_type=None, bind_to=None, force=False):
5267
directory = bzrdir.BzrDir.open(location)
5268
if target_type is None:
5269
raise errors.BzrCommandError('No target configuration specified')
5270
elif target_type == 'branch':
5271
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5272
elif target_type == 'tree':
5273
reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5274
elif target_type == 'checkout':
5275
reconfiguration = reconfigure.Reconfigure.to_checkout(
5276
directory, bind_to)
5277
elif target_type == 'lightweight-checkout':
5278
reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5279
directory, bind_to)
5280
elif target_type == 'use-shared':
5281
reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5282
elif target_type == 'standalone':
5283
reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5284
elif target_type == 'with-trees':
5285
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5286
directory, True)
5287
elif target_type == 'with-no-trees':
5288
reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5289
directory, False)
5290
reconfiguration.apply(force)
5291
5292
5293
class cmd_switch(Command):
5294
"""Set the branch of a checkout and update.
5295
5296
For lightweight checkouts, this changes the branch being referenced.
5297
For heavyweight checkouts, this checks that there are no local commits
5298
versus the current bound branch, then it makes the local branch a mirror
5299
of the new location and binds to it.
5300
5301
In both cases, the working tree is updated and uncommitted changes
5302
are merged. The user can commit or revert these as they desire.
5303
5304
Pending merges need to be committed or reverted before using switch.
5305
5306
The path to the branch to switch to can be specified relative to the parent
5307
directory of the current branch. For example, if you are currently in a
5308
checkout of /path/to/branch, specifying 'newbranch' will find a branch at
5309
/path/to/newbranch.
5310
5311
Bound branches use the nickname of its master branch unless it is set
5312
locally, in which case switching will update the the local nickname to be
5313
that of the master.
5314
"""
5315
5316
takes_args = ['to_location']
5317
takes_options = [Option('force',
5318
help='Switch even if local commits will be lost.'),
5319
Option('create-branch', short_name='b',
5320
help='Create the target branch from this one before'
5321
' switching to it.'),
5322
]
5323
5324
def run(self, to_location, force=False, create_branch=False):
5325
from bzrlib import switch
5326
tree_location = '.'
5327
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5328
try:
5329
branch = control_dir.open_branch()
5330
had_explicit_nick = branch.get_config().has_explicit_nickname()
5331
except errors.NotBranchError:
5332
branch = None
5333
had_explicit_nick = False
5334
if create_branch:
5335
if branch is None:
5336
raise errors.BzrCommandError('cannot create branch without'
5337
' source branch')
5338
if '/' not in to_location and '\\' not in to_location:
5339
# This path is meant to be relative to the existing branch
5340
this_url = self._get_branch_location(control_dir)
5341
to_location = urlutils.join(this_url, '..', to_location)
5342
to_branch = branch.bzrdir.sprout(to_location,
5343
possible_transports=[branch.bzrdir.root_transport],
5344
source_branch=branch).open_branch()
5345
# try:
5346
# from_branch = control_dir.open_branch()
5347
# except errors.NotBranchError:
5348
# raise BzrCommandError('Cannot create a branch from this'
5349
# ' location when we cannot open this branch')
5350
# from_branch.bzrdir.sprout(
5351
pass
5352
else:
5353
try:
5354
to_branch = Branch.open(to_location)
5355
except errors.NotBranchError:
5356
this_url = self._get_branch_location(control_dir)
5357
to_branch = Branch.open(
5358
urlutils.join(this_url, '..', to_location))
5359
switch.switch(control_dir, to_branch, force)
5360
if had_explicit_nick:
5361
branch = control_dir.open_branch() #get the new branch!
5362
branch.nick = to_branch.nick
5363
note('Switched to branch: %s',
5364
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5365
5366
def _get_branch_location(self, control_dir):
5367
"""Return location of branch for this control dir."""
5368
try:
5369
this_branch = control_dir.open_branch()
5370
# This may be a heavy checkout, where we want the master branch
5371
master_location = this_branch.get_bound_location()
5372
if master_location is not None:
5373
return master_location
5374
# If not, use a local sibling
5375
return this_branch.base
5376
except errors.NotBranchError:
5377
format = control_dir.find_branch_format()
5378
if getattr(format, 'get_reference', None) is not None:
5379
return format.get_reference(control_dir)
5380
else:
5381
return control_dir.root_transport.base
5382
5383
5384
class cmd_view(Command):
5385
"""Manage filtered views.
5386
5387
Views provide a mask over the tree so that users can focus on
5388
a subset of a tree when doing their work. After creating a view,
5389
commands that support a list of files - status, diff, commit, etc -
5390
effectively have that list of files implicitly given each time.
5391
An explicit list of files can still be given but those files
5392
must be within the current view.
5393
5394
In most cases, a view has a short life-span: it is created to make
5395
a selected change and is deleted once that change is committed.
5396
At other times, you may wish to create one or more named views
5397
and switch between them.
5398
5399
To disable the current view without deleting it, you can switch to
5400
the pseudo view called ``off``. This can be useful when you need
5401
to see the whole tree for an operation or two (e.g. merge) but
5402
want to switch back to your view after that.
5403
5404
:Examples:
5405
To define the current view::
5406
5407
bzr view file1 dir1 ...
5408
5409
To list the current view::
5410
5411
bzr view
5412
5413
To delete the current view::
5414
5415
bzr view --delete
5416
5417
To disable the current view without deleting it::
5418
5419
bzr view --switch off
5420
5421
To define a named view and switch to it::
5422
5423
bzr view --name view-name file1 dir1 ...
5424
5425
To list a named view::
5426
5427
bzr view --name view-name
5428
5429
To delete a named view::
5430
5431
bzr view --name view-name --delete
5432
5433
To switch to a named view::
5434
5435
bzr view --switch view-name
5436
5437
To list all views defined::
5438
5439
bzr view --all
5440
5441
To delete all views::
5442
5443
bzr view --delete --all
5444
"""
5445
5446
_see_also = []
5447
takes_args = ['file*']
5448
takes_options = [
5449
Option('all',
5450
help='Apply list or delete action to all views.',
5451
),
5452
Option('delete',
5453
help='Delete the view.',
5454
),
5455
Option('name',
5456
help='Name of the view to define, list or delete.',
5457
type=unicode,
5458
),
5459
Option('switch',
5460
help='Name of the view to switch to.',
5461
type=unicode,
5462
),
5463
]
5464
5465
def run(self, file_list,
5466
all=False,
5467
delete=False,
5468
name=None,
5469
switch=None,
5470
):
5471
tree, file_list = tree_files(file_list, apply_view=False)
5472
current_view, view_dict = tree.views.get_view_info()
5473
if name is None:
5474
name = current_view
5475
if delete:
5476
if file_list:
5477
raise errors.BzrCommandError(
5478
"Both --delete and a file list specified")
5479
elif switch:
5480
raise errors.BzrCommandError(
5481
"Both --delete and --switch specified")
5482
elif all:
5483
tree.views.set_view_info(None, {})
5484
self.outf.write("Deleted all views.\n")
5485
elif name is None:
5486
raise errors.BzrCommandError("No current view to delete")
5487
else:
5488
tree.views.delete_view(name)
5489
self.outf.write("Deleted '%s' view.\n" % name)
5490
elif switch:
5491
if file_list:
5492
raise errors.BzrCommandError(
5493
"Both --switch and a file list specified")
5494
elif all:
5495
raise errors.BzrCommandError(
5496
"Both --switch and --all specified")
5497
elif switch == 'off':
5498
if current_view is None:
5499
raise errors.BzrCommandError("No current view to disable")
5500
tree.views.set_view_info(None, view_dict)
5501
self.outf.write("Disabled '%s' view.\n" % (current_view))
5502
else:
5503
tree.views.set_view_info(switch, view_dict)
5504
view_str = views.view_display_str(tree.views.lookup_view())
5505
self.outf.write("Using '%s' view: %s\n" % (switch, view_str))
5506
elif all:
5507
if view_dict:
5508
self.outf.write('Views defined:\n')
5509
for view in sorted(view_dict):
5510
if view == current_view:
5511
active = "=>"
5512
else:
5513
active = " "
5514
view_str = views.view_display_str(view_dict[view])
5515
self.outf.write('%s %-20s %s\n' % (active, view, view_str))
5516
else:
5517
self.outf.write('No views defined.\n')
5518
elif file_list:
5519
if name is None:
5520
# No name given and no current view set
5521
name = 'my'
5522
elif name == 'off':
5523
raise errors.BzrCommandError(
5524
"Cannot change the 'off' pseudo view")
5525
tree.views.set_view(name, sorted(file_list))
5526
view_str = views.view_display_str(tree.views.lookup_view())
5527
self.outf.write("Using '%s' view: %s\n" % (name, view_str))
5528
else:
5529
# list the files
5530
if name is None:
5531
# No name given and no current view set
5532
self.outf.write('No current view.\n')
5533
else:
5534
view_str = views.view_display_str(tree.views.lookup_view(name))
5535
self.outf.write("'%s' view is: %s\n" % (name, view_str))
5536
5537
5538
class cmd_hooks(Command):
5539
"""Show hooks."""
5540
5541
hidden = True
5542
5543
def run(self):
5544
for hook_key in sorted(hooks.known_hooks.keys()):
5545
some_hooks = hooks.known_hooks_key_to_object(hook_key)
5546
self.outf.write("%s:\n" % type(some_hooks).__name__)
5547
for hook_name, hook_point in sorted(some_hooks.items()):
5548
self.outf.write(" %s:\n" % (hook_name,))
5549
found_hooks = list(hook_point)
5550
if found_hooks:
5551
for hook in found_hooks:
5552
self.outf.write(" %s\n" %
5553
(some_hooks.get_hook_name(hook),))
5554
else:
5555
self.outf.write(" <no hooks installed>\n")
5556
5557
5558
class cmd_shelve(Command):
5559
"""Temporarily set aside some changes from the current tree.
5560
5561
Shelve allows you to temporarily put changes you've made "on the shelf",
5562
ie. out of the way, until a later time when you can bring them back from
5563
the shelf with the 'unshelve' command. The changes are stored alongside
5564
your working tree, and so they aren't propagated along with your branch nor
5565
will they survive its deletion.
5566
5567
If shelve --list is specified, previously-shelved changes are listed.
5568
5569
Shelve is intended to help separate several sets of changes that have
5570
been inappropriately mingled. If you just want to get rid of all changes
5571
and you don't need to restore them later, use revert. If you want to
5572
shelve all text changes at once, use shelve --all.
5573
5574
If filenames are specified, only the changes to those files will be
5575
shelved. Other files will be left untouched.
5576
5577
If a revision is specified, changes since that revision will be shelved.
5578
5579
You can put multiple items on the shelf, and by default, 'unshelve' will
5580
restore the most recently shelved changes.
5581
"""
5582
5583
takes_args = ['file*']
5584
5585
takes_options = [
5586
'revision',
5587
Option('all', help='Shelve all changes.'),
5588
'message',
5589
RegistryOption('writer', 'Method to use for writing diffs.',
5590
bzrlib.option.diff_writer_registry,
5591
value_switches=True, enum_switch=False),
5592
5593
Option('list', help='List shelved changes.'),
5594
Option('destroy',
5595
help='Destroy removed changes instead of shelving them.'),
5596
]
5597
_see_also = ['unshelve']
5598
5599
def run(self, revision=None, all=False, file_list=None, message=None,
5600
writer=None, list=False, destroy=False):
5601
if list:
5602
return self.run_for_list()
5603
from bzrlib.shelf_ui import Shelver
5604
if writer is None:
5605
writer = bzrlib.option.diff_writer_registry.get()
5606
try:
5607
Shelver.from_args(writer(sys.stdout), revision, all, file_list,
5608
message, destroy=destroy).run()
5609
except errors.UserAbort:
2748
2749
2750
2751
# command-line interpretation helper for merge-related commands
2752
def merge(other_revision, base_revision,
2753
check_clean=True, ignore_zero=False,
2754
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2755
file_list=None, show_base=False, reprocess=False,
2756
pb=DummyProgress()):
2757
"""Merge changes into a tree.
2758
2759
base_revision
2760
list(path, revno) Base for three-way merge.
2761
If [None, None] then a base will be automatically determined.
2762
other_revision
2763
list(path, revno) Other revision for three-way merge.
2764
this_dir
2765
Directory to merge changes into; '.' by default.
2766
check_clean
2767
If true, this_dir must have no uncommitted changes before the
2768
merge begins.
2769
ignore_zero - If true, suppress the "zero conflicts" message when
2770
there are no conflicts; should be set when doing something we expect
2771
to complete perfectly.
2772
file_list - If supplied, merge only changes to selected files.
2773
2774
All available ancestors of other_revision and base_revision are
2775
automatically pulled into the branch.
2776
2777
The revno may be -1 to indicate the last revision on the branch, which is
2778
the typical case.
2779
2780
This function is intended for use from the command line; programmatic
2781
clients might prefer to call merge.merge_inner(), which has less magic
2782
behavior.
2783
"""
2784
from bzrlib.merge import Merger
2785
if this_dir is None:
2786
this_dir = u'.'
2787
this_tree = WorkingTree.open_containing(this_dir)[0]
2788
if show_base and not merge_type is Merge3Merger:
2789
raise BzrCommandError("Show-base is not supported for this merge"
2790
" type. %s" % merge_type)
2791
if reprocess and not merge_type.supports_reprocess:
2792
raise BzrCommandError("Conflict reduction is not supported for merge"
2793
" type %s." % merge_type)
2794
if reprocess and show_base:
2795
raise BzrCommandError("Cannot do conflict reduction and show base.")
2796
try:
2797
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2798
merger.pp = ProgressPhase("Merge phase", 5, pb)
2799
merger.pp.next_phase()
2800
merger.check_basis(check_clean)
2801
merger.set_other(other_revision)
2802
merger.pp.next_phase()
2803
merger.set_base(base_revision)
2804
if merger.base_rev_id == merger.other_rev_id:
2805
note('Nothing to do.')
5610
2806
return 0
5611
5612
def run_for_list(self):
5613
tree = WorkingTree.open_containing('.')[0]
5614
tree.lock_read()
5615
try:
5616
manager = tree.get_shelf_manager()
5617
shelves = manager.active_shelves()
5618
if len(shelves) == 0:
5619
note('No shelved changes.')
5620
return 0
5621
for shelf_id in reversed(shelves):
5622
message = manager.get_metadata(shelf_id).get('message')
5623
if message is None:
5624
message = '<no message>'
5625
self.outf.write('%3d: %s\n' % (shelf_id, message))
5626
return 1
5627
finally:
5628
tree.unlock()
5629
5630
5631
class cmd_unshelve(Command):
5632
"""Restore shelved changes.
5633
5634
By default, the most recently shelved changes are restored. However if you
5635
specify a shelf by id those changes will be restored instead. This works
5636
best when the changes don't depend on each other.
5637
"""
5638
5639
takes_args = ['shelf_id?']
5640
takes_options = [
5641
RegistryOption.from_kwargs(
5642
'action', help="The action to perform.",
5643
enum_switch=False, value_switches=True,
5644
apply="Apply changes and remove from the shelf.",
5645
dry_run="Show changes, but do not apply or remove them.",
5646
delete_only="Delete changes without applying them."
5647
)
5648
]
5649
_see_also = ['shelve']
5650
5651
def run(self, shelf_id=None, action='apply'):
5652
from bzrlib.shelf_ui import Unshelver
5653
Unshelver.from_args(shelf_id, action).run()
5654
5655
5656
class cmd_clean_tree(Command):
5657
"""Remove unwanted files from working tree.
5658
5659
By default, only unknown files, not ignored files, are deleted. Versioned
5660
files are never deleted.
5661
5662
Another class is 'detritus', which includes files emitted by bzr during
5663
normal operations and selftests. (The value of these files decreases with
5664
time.)
5665
5666
If no options are specified, unknown files are deleted. Otherwise, option
5667
flags are respected, and may be combined.
5668
5669
To check what clean-tree will do, use --dry-run.
5670
"""
5671
takes_options = [Option('ignored', help='Delete all ignored files.'),
5672
Option('detritus', help='Delete conflict files, merge'
5673
' backups, and failed selftest dirs.'),
5674
Option('unknown',
5675
help='Delete files unknown to bzr (default).'),
5676
Option('dry-run', help='Show files to delete instead of'
5677
' deleting them.'),
5678
Option('force', help='Do not prompt before deleting.')]
5679
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5680
force=False):
5681
from bzrlib.clean_tree import clean_tree
5682
if not (unknown or ignored or detritus):
5683
unknown = True
5684
if dry_run:
5685
force = True
5686
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5687
dry_run=dry_run, no_prompt=force)
5688
5689
5690
class cmd_reference(Command):
5691
"""list, view and set branch locations for nested trees.
5692
5693
If no arguments are provided, lists the branch locations for nested trees.
5694
If one argument is provided, display the branch location for that tree.
5695
If two arguments are provided, set the branch location for that tree.
5696
"""
5697
5698
hidden = True
5699
5700
takes_args = ['path?', 'location?']
5701
5702
def run(self, path=None, location=None):
5703
branchdir = '.'
5704
if path is not None:
5705
branchdir = path
5706
tree, branch, relpath =(
5707
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
5708
if path is not None:
5709
path = relpath
5710
if tree is None:
5711
tree = branch.basis_tree()
5712
if path is None:
5713
info = branch._get_all_reference_info().iteritems()
5714
self._display_reference_info(tree, branch, info)
5715
else:
5716
file_id = tree.path2id(path)
5717
if file_id is None:
5718
raise errors.NotVersionedError(path)
5719
if location is None:
5720
info = [(file_id, branch.get_reference_info(file_id))]
5721
self._display_reference_info(tree, branch, info)
5722
else:
5723
branch.set_reference_info(file_id, path, location)
5724
5725
def _display_reference_info(self, tree, branch, info):
5726
ref_list = []
5727
for file_id, (path, location) in info:
5728
try:
5729
path = tree.id2path(file_id)
5730
except errors.NoSuchId:
5731
pass
5732
ref_list.append((path, location))
5733
for path, location in sorted(ref_list):
5734
self.outf.write('%s %s\n' % (path, location))
2807
merger.backup_files = backup_files
2808
merger.merge_type = merge_type
2809
merger.set_interesting_files(file_list)
2810
merger.show_base = show_base
2811
merger.reprocess = reprocess
2812
conflicts = merger.do_merge()
2813
if file_list is None:
2814
merger.set_pending()
2815
finally:
2816
pb.clear()
2817
return conflicts
5735
2818
5736
2819
5737
2820
# these get imported and then picked up by the scan for cmd_*
5738
2821
# TODO: Some more consistent way to split command definitions across files;
5739
# we do need to load at least some information about them to know of
2822
# we do need to load at least some information about them to know of
5740
2823
# aliases. ideally we would avoid loading the implementation until the
5741
2824
# details were needed.
5742
from bzrlib.cmd_version_info import cmd_version_info
5743
2825
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5744
from bzrlib.bundle.commands import (
5745
cmd_bundle_info,
5746
)
5747
from bzrlib.foreign import cmd_dpush
2826
from bzrlib.bundle.commands import cmd_bundle_revisions
5748
2827
from bzrlib.sign_my_commits import cmd_sign_my_commits
5749
from bzrlib.weave_commands import cmd_versionedfile_list, \
2828
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
5750
2829
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1