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