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