« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1551.8.20
- compare with another revision
- download diff
- download tarball
- view history from revision 1551.8.20
- Committer: Aaron Bentley
- Date: 2006-08-30 13:20:22 UTC
- mto: (1731.2.9 nested-trees) (2234.6.1 bzr.0.14) (2229.2.4 reserved-ids) (2323.6.9 0.15-integration) (1551.19.24 Aaron's mergeable stuff)
- mto: This revision was merged to the branch mainline in revision 1976.
- Revision ID: abentley@panoramicfeedback.com-20060830132022-f1abf26606b57595
Fix BzrDir.create_workingtree for NULL_REVISION
- files added:
- COPYING.txt
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- tools/doc_generate
- tools/win32
- files removed:
- bzrlib/clone.py
- bzrlib/util/urlgrabber
- notes
- patches
- files renamed:
- bzrlib/changeset.py => bzrlib/bundle/__init__.py
- bzrlib/store/weave.py => bzrlib/store/versioned/__init__.py
- bzrlib/tests/test_annotate.py => bzrlib/tests/blackbox/test_annotate.py
- bzrlib/tests/test_status.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/tests/test_uncommit.py => bzrlib/tests/blackbox/test_uncommit.py
- bzrlib/tests/test_branch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/tests/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/tests/test_revprops.py => bzrlib/tests/repository_implementations/test_revision.py
- bzrlib/tests/test_basis_inventory.py => bzrlib/tests/workingtree_implementations/test_basis_inventory.py
- bzrlib/transport/http.py => bzrlib/transport/http/__init__.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- tutorial.txt => doc/tutorial.txt
- bzr_man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
2
1
# Copyright (C) 2004, 2005, 2006 by 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
# DO NOT change this to cStringIO - it results in control files
20
# written as UCS4
21
# FIXIT! (Only deal with byte streams OR unicode at any one layer.)
22
# RBC 20051018
23
19
24
from StringIO import StringIO
20
import codecs
21
import errno
22
import os
23
import os.path
25
24
import sys
26
import os
27
25
28
26
import bzrlib
29
from bzrlib import BZRDIR
27
from bzrlib import (
28
branch,
29
bundle,
30
bzrdir,
31
config,
32
errors,
33
ignores,
34
log,
35
osutils,
36
repository,
37
transport,
38
ui,
39
urlutils,
40
)
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
from bzrlib.conflicts import ConflictList
30
45
from bzrlib.commands import Command, display_command
31
from bzrlib.branch import Branch
32
from bzrlib.revision import common_ancestor
33
import bzrlib.errors as errors
34
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
47
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch)
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
37
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
38
54
from bzrlib.revisionspec import RevisionSpec
39
import bzrlib.trace
40
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
41
57
from bzrlib.workingtree import WorkingTree
42
from bzrlib.log import show_one_log
43
58
44
59
45
60
def tree_files(file_list, default_branch=u'.'):
49
64
raise BzrCommandError("%s is not in the same branch as %s" %
50
65
(e.path, file_list[0]))
51
66
67
68
# XXX: Bad function name; should possibly also be a class method of
69
# WorkingTree rather than a function.
52
70
def internal_tree_files(file_list, default_branch=u'.'):
53
"""\
54
Return a branch and list of branch-relative paths.
55
If supplied file_list is empty or None, the branch default will be used,
56
and returned file_list will match the original.
71
"""Convert command-line paths to a WorkingTree and relative paths.
72
73
This is typically used for command-line processors that take one or
74
more filenames, and infer the workingtree that contains them.
75
76
The filenames given are not required to exist.
77
78
:param file_list: Filenames to convert.
79
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
81
82
:return: workingtree, [relative_paths]
57
83
"""
58
84
if file_list is None or len(file_list) == 0:
59
85
return WorkingTree.open_containing(default_branch)[0], file_list
67
93
return tree, new_list
68
94
69
95
96
def get_format_type(typestring):
97
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
100
if typestring == "default":
101
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
105
return format
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
109
return format
110
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
111
"metaweave and weave" % typestring
112
raise BzrCommandError(msg)
113
114
70
115
# TODO: Make sure no commands unconditionally use the working directory as a
71
116
# branch. If a filename argument is used, the first of them should be used to
72
117
# specify the branch. (Perhaps this can be factored out into some kind of
94
139
modified
95
140
Text has changed since the previous revision.
96
141
97
unchanged
98
Nothing about this file has changed since the previous revision.
99
Only shown with --all.
100
101
142
unknown
102
143
Not versioned and not matching an ignore pattern.
103
144
116
157
# TODO: --no-recurse, --recurse options
117
158
118
159
takes_args = ['file*']
119
takes_options = ['all', 'show-ids', 'revision']
160
takes_options = ['show-ids', 'revision']
120
161
aliases = ['st', 'stat']
162
163
encoding_type = 'replace'
121
164
122
165
@display_command
123
def run(self, all=False, show_ids=False, file_list=None, revision=None):
166
def run(self, show_ids=False, file_list=None, revision=None):
167
from bzrlib.status import show_tree_status
168
124
169
tree, file_list = tree_files(file_list)
125
170
126
from bzrlib.status import show_status
127
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
128
specific_files=file_list, revision=revision)
171
show_tree_status(tree, show_ids=show_ids,
172
specific_files=file_list, revision=revision,
173
to_file=self.outf)
129
174
130
175
131
176
class cmd_cat_revision(Command):
138
183
hidden = True
139
184
takes_args = ['revision_id?']
140
185
takes_options = ['revision']
186
# cat-revision is more for frontends so should be exact
187
encoding = 'strict'
141
188
142
189
@display_command
143
190
def run(self, revision_id=None, revision=None):
147
194
if revision_id is None and revision is None:
148
195
raise BzrCommandError('You must supply either --revision or a revision_id')
149
196
b = WorkingTree.open_containing(u'.')[0].branch
197
198
# TODO: jam 20060112 should cat-revision always output utf-8?
150
199
if revision_id is not None:
151
sys.stdout.write(b.get_revision_xml(revision_id))
200
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
152
201
elif revision is not None:
153
202
for rev in revision:
154
203
if rev is None:
155
204
raise BzrCommandError('You cannot specify a NULL revision.')
156
205
revno, rev_id = rev.in_history(b)
157
sys.stdout.write(b.get_revision_xml(rev_id))
206
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
158
207
159
208
160
209
class cmd_revno(Command):
161
210
"""Show current revision number.
162
211
163
This is equal to the number of revisions on this branch."""
212
This is equal to the number of revisions on this branch.
213
"""
214
164
215
takes_args = ['location?']
216
165
217
@display_command
166
218
def run(self, location=u'.'):
167
print Branch.open_containing(location)[0].revno()
219
self.outf.write(str(Branch.open_containing(location)[0].revno()))
220
self.outf.write('\n')
168
221
169
222
170
223
class cmd_revision_info(Command):
173
226
hidden = True
174
227
takes_args = ['revision_info*']
175
228
takes_options = ['revision']
229
176
230
@display_command
177
231
def run(self, revision=None, revision_info_list=[]):
178
232
215
269
216
270
Adding a file whose parent directory is not versioned will
217
271
implicitly add the parent, and so on up to the root. This means
218
you should never need to explictly add a directory, they'll just
272
you should never need to explicitly add a directory, they'll just
219
273
get added when you add a file in the directory.
220
274
221
275
--dry-run will show which files would be added, but not actually
222
276
add them.
277
278
--file-ids-from will try to use the file ids from the supplied path.
279
It looks up ids trying to find a matching parent directory with the
280
same filename, and then by pure path.
223
281
"""
224
282
takes_args = ['file*']
225
takes_options = ['no-recurse', 'dry-run', 'verbose']
283
takes_options = ['no-recurse', 'dry-run', 'verbose',
284
Option('file-ids-from', type=unicode,
285
help='Lookup file ids from here')]
286
encoding_type = 'replace'
226
287
227
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
288
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
289
file_ids_from=None):
228
290
import bzrlib.add
229
291
230
if dry_run:
231
if is_quiet():
232
# This is pointless, but I'd rather not raise an error
233
action = bzrlib.add.add_action_null
234
else:
235
action = bzrlib.add.add_action_print
236
elif is_quiet():
237
action = bzrlib.add.add_action_add
292
if file_ids_from is not None:
293
try:
294
base_tree, base_path = WorkingTree.open_containing(
295
file_ids_from)
296
except errors.NoWorkingTree:
297
base_branch, base_path = branch.Branch.open_containing(
298
file_ids_from)
299
base_tree = base_branch.basis_tree()
300
301
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
302
to_file=self.outf, should_print=(not is_quiet()))
238
303
else:
239
action = bzrlib.add.add_action_add_and_print
304
action = bzrlib.add.AddAction(to_file=self.outf,
305
should_print=(not is_quiet()))
240
306
241
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
242
action)
307
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
308
action=action, save=not dry_run)
243
309
if len(ignored) > 0:
244
for glob in sorted(ignored.keys()):
245
match_len = len(ignored[glob])
246
if verbose:
310
if verbose:
311
for glob in sorted(ignored.keys()):
247
312
for path in ignored[glob]:
248
print "ignored %s matching \"%s\"" % (path, glob)
249
else:
250
print "ignored %d file(s) matching \"%s\"" % (match_len,
251
glob)
252
print "If you wish to add some of these files, please add them"\
253
" by name."
313
self.outf.write("ignored %s matching \"%s\"\n"
314
% (path, glob))
315
else:
316
match_len = 0
317
for glob, paths in ignored.items():
318
match_len += len(paths)
319
self.outf.write("ignored %d file(s).\n" % match_len)
320
self.outf.write("If you wish to add some of these files,"
321
" please add them by name.\n")
254
322
255
323
256
324
class cmd_mkdir(Command):
258
326
259
327
This is equivalent to creating the directory and then adding it.
260
328
"""
329
261
330
takes_args = ['dir+']
331
encoding_type = 'replace'
262
332
263
333
def run(self, dir_list):
264
334
for d in dir_list:
265
335
os.mkdir(d)
266
336
wt, dd = WorkingTree.open_containing(d)
267
337
wt.add([dd])
268
print 'added', d
338
self.outf.write('added %s\n' % d)
269
339
270
340
271
341
class cmd_relpath(Command):
272
342
"""Show path of a file relative to root"""
343
273
344
takes_args = ['filename']
274
345
hidden = True
275
346
276
347
@display_command
277
348
def run(self, filename):
349
# TODO: jam 20050106 Can relpath return a munged path if
350
# sys.stdout encoding cannot represent it?
278
351
tree, relpath = WorkingTree.open_containing(filename)
279
print relpath
352
self.outf.write(relpath)
353
self.outf.write('\n')
280
354
281
355
282
356
class cmd_inventory(Command):
285
359
It is possible to limit the output to a particular entry
286
360
type using the --kind option. For example; --kind file.
287
361
"""
362
288
363
takes_options = ['revision', 'show-ids', 'kind']
289
364
290
365
@display_command
298
373
if len(revision) > 1:
299
374
raise BzrCommandError('bzr inventory --revision takes'
300
375
' exactly one revision identifier')
301
inv = tree.branch.get_revision_inventory(
376
inv = tree.branch.repository.get_revision_inventory(
302
377
revision[0].in_history(tree.branch).rev_id)
303
378
304
379
for path, entry in inv.entries():
305
380
if kind and kind != entry.kind:
306
381
continue
307
382
if show_ids:
308
print '%-50s %s' % (path, entry.file_id)
383
self.outf.write('%-50s %s\n' % (path, entry.file_id))
309
384
else:
310
print path
311
312
313
class cmd_move(Command):
314
"""Move files to a different directory.
315
316
examples:
317
bzr move *.txt doc
318
319
The destination must be a versioned directory in the same branch.
320
"""
321
takes_args = ['source$', 'dest']
322
def run(self, source_list, dest):
323
tree, source_list = tree_files(source_list)
324
# TODO: glob expansion on windows?
325
tree.move(source_list, tree.relpath(dest))
326
327
328
class cmd_rename(Command):
329
"""Change the name of an entry.
330
331
examples:
332
bzr rename frob.c frobber.c
333
bzr rename src/frob.c lib/frob.c
334
335
It is an error if the destination name exists.
336
337
See also the 'move' command, which moves files into a different
338
directory without changing their name.
339
"""
340
# TODO: Some way to rename multiple files without invoking
341
# bzr for each one?"""
342
takes_args = ['from_name', 'to_name']
343
344
def run(self, from_name, to_name):
345
tree, (from_name, to_name) = tree_files((from_name, to_name))
346
tree.rename_one(from_name, to_name)
385
self.outf.write(path)
386
self.outf.write('\n')
347
387
348
388
349
389
class cmd_mv(Command):
359
399
360
400
Files cannot be moved between branches.
361
401
"""
402
362
403
takes_args = ['names*']
404
aliases = ['move', 'rename']
405
encoding_type = 'replace'
406
363
407
def run(self, names_list):
408
if names_list is None:
409
names_list = []
410
364
411
if len(names_list) < 2:
365
412
raise BzrCommandError("missing file argument")
366
413
tree, rel_names = tree_files(names_list)
368
415
if os.path.isdir(names_list[-1]):
369
416
# move into existing directory
370
417
for pair in tree.move(rel_names[:-1], rel_names[-1]):
371
print "%s => %s" % pair
418
self.outf.write("%s => %s\n" % pair)
372
419
else:
373
420
if len(names_list) != 2:
374
421
raise BzrCommandError('to mv multiple files the destination '
375
422
'must be a versioned directory')
376
423
tree.rename_one(rel_names[0], rel_names[1])
377
print "%s => %s" % (rel_names[0], rel_names[1])
424
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
378
425
379
426
380
427
class cmd_pull(Command):
381
"""Pull any changes from another branch into the current one.
382
383
If there is no default location set, the first pull will set it. After
384
that, you can omit the location to use the default. To change the
385
default, use --remember.
428
"""Turn this branch into a mirror of another branch.
386
429
387
430
This command only works on branches that have not diverged. Branches are
388
considered diverged if both branches have had commits without first
389
pulling from the other.
431
considered diverged if the destination branch's most recent commit is one
432
that has not been merged (directly or indirectly) into the parent.
390
433
391
If branches have diverged, you can use 'bzr merge' to pull the text changes
434
If branches have diverged, you can use 'bzr merge' to integrate the changes
392
435
from one into the other. Once one branch has merged, the other should
393
436
be able to pull it again.
394
437
395
438
If you want to forget your local changes and just update your branch to
396
match the remote one, use --overwrite.
439
match the remote one, use pull --overwrite.
440
441
If there is no default location set, the first pull will set it. After
442
that, you can omit the location to use the default. To change the
443
default, use --remember. The value will only be saved if the remote
444
location can be accessed.
397
445
"""
398
takes_options = ['remember', 'overwrite', 'verbose']
446
447
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
399
448
takes_args = ['location?']
400
401
def run(self, location=None, remember=False, overwrite=False, verbose=False):
402
from bzrlib.merge import merge
403
from shutil import rmtree
404
import errno
405
# FIXME: too much stuff is in the command class
406
tree_to = WorkingTree.open_containing(u'.')[0]
407
stored_loc = tree_to.branch.get_parent()
449
encoding_type = 'replace'
450
451
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
452
# FIXME: too much stuff is in the command class
453
try:
454
tree_to = WorkingTree.open_containing(u'.')[0]
455
branch_to = tree_to.branch
456
except NoWorkingTree:
457
tree_to = None
458
branch_to = Branch.open_containing(u'.')[0]
459
460
reader = None
461
if location is not None:
462
try:
463
reader = bundle.read_bundle_from_url(location)
464
except NotABundle:
465
pass # Continue on considering this url a Branch
466
467
stored_loc = branch_to.get_parent()
408
468
if location is None:
409
469
if stored_loc is None:
410
470
raise BzrCommandError("No pull location known or specified.")
411
471
else:
412
print "Using saved location: %s" % stored_loc
472
display_url = urlutils.unescape_for_display(stored_loc,
473
self.outf.encoding)
474
self.outf.write("Using saved location: %s\n" % display_url)
413
475
location = stored_loc
414
476
415
br_from = Branch.open(location)
416
br_to = tree_to.branch
417
418
old_rh = br_to.revision_history()
419
count = tree_to.pull(br_from, overwrite)
420
421
if br_to.get_parent() is None or remember:
422
br_to.set_parent(location)
477
478
if reader is not None:
479
install_bundle(branch_to.repository, reader)
480
branch_from = branch_to
481
else:
482
branch_from = Branch.open(location)
483
484
if branch_to.get_parent() is None or remember:
485
branch_to.set_parent(branch_from.base)
486
487
rev_id = None
488
if revision is None:
489
if reader is not None:
490
rev_id = reader.target
491
elif len(revision) == 1:
492
rev_id = revision[0].in_history(branch_from).rev_id
493
else:
494
raise BzrCommandError('bzr pull --revision takes one value.')
495
496
old_rh = branch_to.revision_history()
497
if tree_to is not None:
498
count = tree_to.pull(branch_from, overwrite, rev_id)
499
else:
500
count = branch_to.pull(branch_from, overwrite, rev_id)
423
501
note('%d revision(s) pulled.' % (count,))
424
502
425
503
if verbose:
426
new_rh = tree_to.branch.revision_history()
504
new_rh = branch_to.revision_history()
427
505
if old_rh != new_rh:
428
506
# Something changed
429
507
from bzrlib.log import show_changed_revisions
430
show_changed_revisions(tree_to.branch, old_rh, new_rh)
508
show_changed_revisions(branch_to, old_rh, new_rh,
509
to_file=self.outf)
431
510
432
511
433
512
class cmd_push(Command):
434
"""Push this branch into another branch.
435
436
The remote branch will not have its working tree populated because this
437
is both expensive, and may not be supported on the remote file system.
438
439
Some smart servers or protocols *may* put the working tree in place.
513
"""Update a mirror of this branch.
514
515
The target branch will not have its working tree populated because this
516
is both expensive, and is not supported on remote file systems.
517
518
Some smart servers or protocols *may* put the working tree in place in
519
the future.
520
521
This command only works on branches that have not diverged. Branches are
522
considered diverged if the destination branch's most recent commit is one
523
that has not been merged (directly or indirectly) by the source branch.
524
525
If branches have diverged, you can use 'bzr push --overwrite' to replace
526
the other branch completely, discarding its unmerged changes.
527
528
If you want to ensure you have the different changes in the other branch,
529
do a merge (see bzr help merge) from the other branch, and commit that.
530
After that you will be able to do a push without '--overwrite'.
440
531
441
532
If there is no default push location set, the first push will set it.
442
533
After that, you can omit the location to use the default. To change the
443
default, use --remember.
444
445
This command only works on branches that have not diverged. Branches are
446
considered diverged if the branch being pushed to is not an older version
447
of this branch.
448
449
If branches have diverged, you can use 'bzr push --overwrite' to replace
450
the other branch completely.
451
452
If you want to ensure you have the different changes in the other branch,
453
do a merge (see bzr help merge) from the other branch, and commit that
454
before doing a 'push --overwrite'.
534
default, use --remember. The value will only be saved if the remote
535
location can be accessed.
455
536
"""
456
takes_options = ['remember', 'overwrite',
537
538
takes_options = ['remember', 'overwrite', 'verbose',
457
539
Option('create-prefix',
458
540
help='Create the path leading up to the branch '
459
541
'if it does not already exist')]
460
542
takes_args = ['location?']
543
encoding_type = 'replace'
461
544
462
545
def run(self, location=None, remember=False, overwrite=False,
463
546
create_prefix=False, verbose=False):
464
547
# FIXME: Way too big! Put this into a function called from the
465
548
# command.
466
import errno
467
from shutil import rmtree
468
from bzrlib.transport import get_transport
469
549
470
tree_from = WorkingTree.open_containing(u'.')[0]
471
br_from = tree_from.branch
472
stored_loc = tree_from.branch.get_push_location()
550
br_from = Branch.open_containing('.')[0]
551
stored_loc = br_from.get_push_location()
473
552
if location is None:
474
553
if stored_loc is None:
475
554
raise BzrCommandError("No push location known or specified.")
476
555
else:
477
print "Using saved location: %s" % stored_loc
556
display_url = urlutils.unescape_for_display(stored_loc,
557
self.outf.encoding)
558
self.outf.write("Using saved location: %s\n" % display_url)
478
559
location = stored_loc
560
561
to_transport = transport.get_transport(location)
562
location_url = to_transport.base
563
564
old_rh = []
479
565
try:
480
br_to = Branch.open(location)
566
dir_to = bzrdir.BzrDir.open(location_url)
567
br_to = dir_to.open_branch()
481
568
except NotBranchError:
482
569
# create a branch.
483
transport = get_transport(location).clone('..')
570
to_transport = to_transport.clone('..')
484
571
if not create_prefix:
485
572
try:
486
transport.mkdir(transport.relpath(location))
573
relurl = to_transport.relpath(location_url)
574
mutter('creating directory %s => %s', location_url, relurl)
575
to_transport.mkdir(relurl)
487
576
except NoSuchFile:
488
577
raise BzrCommandError("Parent directory of %s "
489
578
"does not exist." % location)
490
579
else:
491
current = transport.base
492
needed = [(transport, transport.relpath(location))]
580
current = to_transport.base
581
needed = [(to_transport, to_transport.relpath(location_url))]
493
582
while needed:
494
583
try:
495
transport, relpath = needed[-1]
496
transport.mkdir(relpath)
584
to_transport, relpath = needed[-1]
585
to_transport.mkdir(relpath)
497
586
needed.pop()
498
587
except NoSuchFile:
499
new_transport = transport.clone('..')
588
new_transport = to_transport.clone('..')
500
589
needed.append((new_transport,
501
new_transport.relpath(transport.base)))
502
if new_transport.base == transport.base:
503
raise BzrCommandError("Could not creeate "
590
new_transport.relpath(to_transport.base)))
591
if new_transport.base == to_transport.base:
592
raise BzrCommandError("Could not create "
504
593
"path prefix.")
505
br_to = Branch.initialize(location)
506
old_rh = br_to.revision_history()
507
try:
594
dir_to = br_from.bzrdir.clone(location_url,
595
revision_id=br_from.last_revision())
596
br_to = dir_to.open_branch()
597
count = len(br_to.revision_history())
598
# We successfully created the target, remember it
599
if br_from.get_push_location() is None or remember:
600
br_from.set_push_location(br_to.base)
601
else:
602
# We were able to connect to the remote location, so remember it
603
# we don't need to successfully push because of possible divergence.
604
if br_from.get_push_location() is None or remember:
605
br_from.set_push_location(br_to.base)
606
old_rh = br_to.revision_history()
508
607
try:
509
tree_to = br_to.working_tree()
510
except NoWorkingTree:
511
# TODO: This should be updated for branches which don't have a
512
# working tree, as opposed to ones where we just couldn't
513
# update the tree.
514
warning('Unable to update the working tree of: %s' % (br_to.base,))
515
count = br_to.pull(br_from, overwrite)
516
else:
517
count = tree_to.pull(br_from, overwrite)
518
except DivergedBranches:
519
raise BzrCommandError("These branches have diverged."
520
" Try a merge then push with overwrite.")
521
if br_from.get_push_location() is None or remember:
522
br_from.set_push_location(location)
608
try:
609
tree_to = dir_to.open_workingtree()
610
except errors.NotLocalUrl:
611
warning('This transport does not update the working '
612
'tree of: %s' % (br_to.base,))
613
count = br_to.pull(br_from, overwrite)
614
except NoWorkingTree:
615
count = br_to.pull(br_from, overwrite)
616
else:
617
count = tree_to.pull(br_from, overwrite)
618
except DivergedBranches:
619
raise BzrCommandError("These branches have diverged."
620
" Try a merge then push with overwrite.")
523
621
note('%d revision(s) pushed.' % (count,))
524
622
525
623
if verbose:
527
625
if old_rh != new_rh:
528
626
# Something changed
529
627
from bzrlib.log import show_changed_revisions
530
show_changed_revisions(br_to, old_rh, new_rh)
628
show_changed_revisions(br_to, old_rh, new_rh,
629
to_file=self.outf)
531
630
532
631
533
632
class cmd_branch(Command):
548
647
aliases = ['get', 'clone']
549
648
550
649
def run(self, from_location, to_location=None, revision=None, basis=None):
551
from bzrlib.clone import copy_branch
552
import errno
553
from shutil import rmtree
554
650
if revision is None:
555
651
revision = [None]
556
652
elif len(revision) > 1:
567
663
br_from.lock_read()
568
664
try:
569
665
if basis is not None:
570
basis_branch = WorkingTree.open_containing(basis)[0].branch
666
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
571
667
else:
572
basis_branch = None
668
basis_dir = None
573
669
if len(revision) == 1 and revision[0] is not None:
574
670
revision_id = revision[0].in_history(br_from)[1]
575
671
else:
576
revision_id = None
672
# FIXME - wt.last_revision, fallback to branch, fall back to
673
# None or perhaps NULL_REVISION to mean copy nothing
674
# RBC 20060209
675
revision_id = br_from.last_revision()
577
676
if to_location is None:
578
677
to_location = os.path.basename(from_location.rstrip("/\\"))
579
678
name = None
580
679
else:
581
680
name = os.path.basename(to_location) + '\n'
582
try:
583
os.mkdir(to_location)
584
except OSError, e:
585
if e.errno == errno.EEXIST:
586
raise BzrCommandError('Target directory "%s" already'
587
' exists.' % to_location)
588
if e.errno == errno.ENOENT:
589
raise BzrCommandError('Parent of "%s" does not exist.' %
590
to_location)
591
else:
592
raise
593
try:
594
copy_branch(br_from, to_location, revision_id, basis_branch)
595
except bzrlib.errors.NoSuchRevision:
596
rmtree(to_location)
681
682
to_transport = transport.get_transport(to_location)
683
try:
684
to_transport.mkdir('.')
685
except errors.FileExists:
686
raise BzrCommandError('Target directory "%s" already'
687
' exists.' % to_location)
688
except errors.NoSuchFile:
689
raise BzrCommandError('Parent of "%s" does not exist.' %
690
to_location)
691
try:
692
# preserve whatever source format we have.
693
dir = br_from.bzrdir.sprout(to_transport.base,
694
revision_id, basis_dir)
695
branch = dir.open_branch()
696
except errors.NoSuchRevision:
697
to_transport.delete_tree('.')
597
698
msg = "The branch %s has no revision %s." % (from_location, revision[0])
598
699
raise BzrCommandError(msg)
599
except bzrlib.errors.UnlistableBranch:
600
rmtree(to_location)
601
msg = "The branch %s cannot be used as a --basis"
700
except errors.UnlistableBranch:
701
osutils.rmtree(to_location)
702
msg = "The branch %s cannot be used as a --basis" % (basis,)
602
703
raise BzrCommandError(msg)
603
branch = Branch.open(to_location)
604
704
if name:
605
name = StringIO(name)
606
branch.put_controlfile('branch-name', name)
705
branch.control_files.put_utf8('branch-name', name)
607
706
note('Branched %d revision(s).' % branch.revno())
608
707
finally:
609
708
br_from.unlock()
610
709
611
710
711
class cmd_checkout(Command):
712
"""Create a new checkout of an existing branch.
713
714
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
715
the branch found in '.'. This is useful if you have removed the working tree
716
or if it was never created - i.e. if you pushed the branch to its current
717
location using SFTP.
718
719
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
720
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
721
722
To retrieve the branch as of a particular revision, supply the --revision
723
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
724
out of date [so you cannot commit] but it may be useful (i.e. to examine old
725
code.)
726
727
--basis is to speed up checking out from remote branches. When specified, it
728
uses the inventory and file contents from the basis branch in preference to the
729
branch being checked out.
730
"""
731
takes_args = ['branch_location?', 'to_location?']
732
takes_options = ['revision', # , 'basis']
733
Option('lightweight',
734
help="perform a lightweight checkout. Lightweight "
735
"checkouts depend on access to the branch for "
736
"every operation. Normal checkouts can perform "
737
"common operations like diff and status without "
738
"such access, and also support local commits."
739
),
740
]
741
aliases = ['co']
742
743
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
744
lightweight=False):
745
if revision is None:
746
revision = [None]
747
elif len(revision) > 1:
748
raise BzrCommandError(
749
'bzr checkout --revision takes exactly 1 revision value')
750
if branch_location is None:
751
branch_location = osutils.getcwd()
752
to_location = branch_location
753
source = Branch.open(branch_location)
754
if len(revision) == 1 and revision[0] is not None:
755
revision_id = revision[0].in_history(source)[1]
756
else:
757
revision_id = None
758
if to_location is None:
759
to_location = os.path.basename(branch_location.rstrip("/\\"))
760
# if the source and to_location are the same,
761
# and there is no working tree,
762
# then reconstitute a branch
763
if (osutils.abspath(to_location) ==
764
osutils.abspath(branch_location)):
765
try:
766
source.bzrdir.open_workingtree()
767
except errors.NoWorkingTree:
768
source.bzrdir.create_workingtree()
769
return
770
try:
771
os.mkdir(to_location)
772
except OSError, e:
773
if e.errno == errno.EEXIST:
774
raise BzrCommandError('Target directory "%s" already'
775
' exists.' % to_location)
776
if e.errno == errno.ENOENT:
777
raise BzrCommandError('Parent of "%s" does not exist.' %
778
to_location)
779
else:
780
raise
781
old_format = bzrdir.BzrDirFormat.get_default_format()
782
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
783
try:
784
source.create_checkout(to_location, revision_id, lightweight)
785
finally:
786
bzrdir.BzrDirFormat.set_default_format(old_format)
787
788
612
789
class cmd_renames(Command):
613
790
"""Show list of renamed files.
614
791
"""
619
796
620
797
@display_command
621
798
def run(self, dir=u'.'):
799
from bzrlib.tree import find_renames
622
800
tree = WorkingTree.open_containing(dir)[0]
623
old_inv = tree.branch.basis_tree().inventory
801
old_inv = tree.basis_tree().inventory
624
802
new_inv = tree.read_working_inventory()
625
626
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
803
renames = list(find_renames(old_inv, new_inv))
627
804
renames.sort()
628
805
for old_name, new_name in renames:
629
print "%s => %s" % (old_name, new_name)
806
self.outf.write("%s => %s\n" % (old_name, new_name))
807
808
809
class cmd_update(Command):
810
"""Update a tree to have the latest code committed to its branch.
811
812
This will perform a merge into the working tree, and may generate
813
conflicts. If you have any local changes, you will still
814
need to commit them after the update for the update to be complete.
815
816
If you want to discard your local changes, you can just do a
817
'bzr revert' instead of 'bzr commit' after the update.
818
"""
819
takes_args = ['dir?']
820
aliases = ['up']
821
822
def run(self, dir='.'):
823
tree = WorkingTree.open_containing(dir)[0]
824
tree.lock_write()
825
try:
826
existing_pending_merges = tree.pending_merges()
827
last_rev = tree.last_revision()
828
if last_rev == tree.branch.last_revision():
829
# may be up to date, check master too.
830
master = tree.branch.get_master_branch()
831
if master is None or last_rev == master.last_revision():
832
revno = tree.branch.revision_id_to_revno(last_rev)
833
note("Tree is up to date at revision %d." % (revno,))
834
return 0
835
conflicts = tree.update()
836
revno = tree.branch.revision_id_to_revno(tree.last_revision())
837
note('Updated to revision %d.' % (revno,))
838
if tree.pending_merges() != existing_pending_merges:
839
note('Your local commits will now show as pending merges with '
840
"'bzr status', and can be committed with 'bzr commit'.")
841
if conflicts != 0:
842
return 1
843
else:
844
return 0
845
finally:
846
tree.unlock()
630
847
631
848
632
849
class cmd_info(Command):
633
"""Show statistical information about a branch."""
634
takes_args = ['branch?']
635
850
"""Show information about a working tree, branch or repository.
851
852
This command will show all known locations and formats associated to the
853
tree, branch or repository. Statistical information is included with
854
each report.
855
856
Branches and working trees will also report any missing revisions.
857
"""
858
takes_args = ['location?']
859
takes_options = ['verbose']
860
636
861
@display_command
637
def run(self, branch=None):
638
import info
639
b = WorkingTree.open_containing(branch)[0].branch
640
info.show_info(b)
862
def run(self, location=None, verbose=False):
863
from bzrlib.info import show_bzrdir_info
864
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
865
verbose=verbose)
641
866
642
867
643
868
class cmd_remove(Command):
645
870
646
871
This makes bzr stop tracking changes to a versioned file. It does
647
872
not delete the working copy.
873
874
You can specify one or more files, and/or --new. If you specify --new,
875
only 'added' files will be removed. If you specify both, then new files
876
in the specified directories will be removed. If the directories are
877
also new, they will also be removed.
648
878
"""
649
takes_args = ['file+']
650
takes_options = ['verbose']
879
takes_args = ['file*']
880
takes_options = ['verbose', Option('new', help='remove newly-added files')]
651
881
aliases = ['rm']
882
encoding_type = 'replace'
652
883
653
def run(self, file_list, verbose=False):
884
def run(self, file_list, verbose=False, new=False):
654
885
tree, file_list = tree_files(file_list)
655
tree.remove(file_list, verbose=verbose)
886
if new is False:
887
if file_list is None:
888
raise BzrCommandError('Specify one or more files to remove, or'
889
' use --new.')
890
else:
891
added = tree.changes_from(tree.basis_tree(),
892
specific_files=file_list).added
893
file_list = sorted([f[0] for f in added], reverse=True)
894
if len(file_list) == 0:
895
raise BzrCommandError('No matching files.')
896
tree.remove(file_list, verbose=verbose, to_file=self.outf)
656
897
657
898
658
899
class cmd_file_id(Command):
662
903
same through all revisions where the file exists, even when it is
663
904
moved or renamed.
664
905
"""
906
665
907
hidden = True
666
908
takes_args = ['filename']
909
667
910
@display_command
668
911
def run(self, filename):
669
912
tree, relpath = WorkingTree.open_containing(filename)
671
914
if i == None:
672
915
raise BzrError("%r is not a versioned file" % filename)
673
916
else:
674
print i
917
self.outf.write(i + '\n')
675
918
676
919
677
920
class cmd_file_path(Command):
678
921
"""Print path of file_ids to a file or directory.
679
922
680
923
This prints one line for each directory down to the target,
681
starting at the branch root."""
924
starting at the branch root.
925
"""
926
682
927
hidden = True
683
928
takes_args = ['filename']
929
684
930
@display_command
685
931
def run(self, filename):
686
932
tree, relpath = WorkingTree.open_containing(filename)
689
935
if fid == None:
690
936
raise BzrError("%r is not a versioned file" % filename)
691
937
for fip in inv.get_idpath(fid):
692
print fip
938
self.outf.write(fip + '\n')
939
940
941
class cmd_reconcile(Command):
942
"""Reconcile bzr metadata in a branch.
943
944
This can correct data mismatches that may have been caused by
945
previous ghost operations or bzr upgrades. You should only
946
need to run this command if 'bzr check' or a bzr developer
947
advises you to run it.
948
949
If a second branch is provided, cross-branch reconciliation is
950
also attempted, which will check that data like the tree root
951
id which was not present in very early bzr versions is represented
952
correctly in both branches.
953
954
At the same time it is run it may recompress data resulting in
955
a potential saving in disk space or performance gain.
956
957
The branch *MUST* be on a listable system such as local disk or sftp.
958
"""
959
takes_args = ['branch?']
960
961
def run(self, branch="."):
962
from bzrlib.reconcile import reconcile
963
dir = bzrdir.BzrDir.open(branch)
964
reconcile(dir)
693
965
694
966
695
967
class cmd_revision_history(Command):
696
"""Display list of revision ids on this branch."""
968
"""Display the list of revision ids on a branch."""
969
takes_args = ['location?']
970
697
971
hidden = True
972
698
973
@display_command
699
def run(self):
700
branch = WorkingTree.open_containing(u'.')[0].branch
701
for patchid in branch.revision_history():
702
print patchid
974
def run(self, location="."):
975
branch = Branch.open_containing(location)[0]
976
for revid in branch.revision_history():
977
self.outf.write(revid)
978
self.outf.write('\n')
703
979
704
980
705
981
class cmd_ancestry(Command):
706
982
"""List all revisions merged into this branch."""
983
takes_args = ['location?']
984
707
985
hidden = True
986
708
987
@display_command
709
def run(self):
710
tree = WorkingTree.open_containing(u'.')[0]
711
b = tree.branch
712
# FIXME. should be tree.last_revision
713
for revision_id in b.get_ancestry(b.last_revision()):
714
print revision_id
988
def run(self, location="."):
989
try:
990
wt = WorkingTree.open_containing(location)[0]
991
except errors.NoWorkingTree:
992
b = Branch.open(location)
993
last_revision = b.last_revision()
994
else:
995
b = wt.branch
996
last_revision = wt.last_revision()
997
998
revision_ids = b.repository.get_ancestry(last_revision)
999
assert revision_ids[0] == None
1000
revision_ids.pop(0)
1001
for revision_id in revision_ids:
1002
self.outf.write(revision_id + '\n')
715
1003
716
1004
717
1005
class cmd_init(Command):
720
1008
Use this to create an empty branch, or before importing an
721
1009
existing project.
722
1010
1011
If there is a repository in a parent directory of the location, then
1012
the history of the branch will be stored in the repository. Otherwise
1013
init creates a standalone branch which carries its own history in
1014
.bzr.
1015
1016
If there is already a branch at the location but it has no working tree,
1017
the tree can be populated with 'bzr checkout'.
1018
723
1019
Recipe for importing a tree of files:
724
1020
cd ~/project
725
1021
bzr init
728
1024
bzr commit -m 'imported project'
729
1025
"""
730
1026
takes_args = ['location?']
731
def run(self, location=None):
732
from bzrlib.branch import Branch
1027
takes_options = [
1028
Option('format',
1029
help='Specify a format for this branch. Current'
1030
' formats are: default, knit, metaweave and'
1031
' weave. Default is knit; metaweave and'
1032
' weave are deprecated',
1033
type=get_format_type),
1034
]
1035
def run(self, location=None, format=None):
1036
if format is None:
1037
format = get_format_type('default')
733
1038
if location is None:
734
1039
location = u'.'
1040
1041
to_transport = transport.get_transport(location)
1042
1043
# The path has to exist to initialize a
1044
# branch inside of it.
1045
# Just using os.mkdir, since I don't
1046
# believe that we want to create a bunch of
1047
# locations if the user supplies an extended path
1048
# TODO: create-prefix
1049
try:
1050
to_transport.mkdir('.')
1051
except errors.FileExists:
1052
pass
1053
1054
try:
1055
existing_bzrdir = bzrdir.BzrDir.open(location)
1056
except NotBranchError:
1057
# really a NotBzrDir error...
1058
bzrdir.BzrDir.create_branch_convenience(location, format=format)
735
1059
else:
736
# The path has to exist to initialize a
737
# branch inside of it.
738
# Just using os.mkdir, since I don't
739
# believe that we want to create a bunch of
740
# locations if the user supplies an extended path
741
if not os.path.exists(location):
742
os.mkdir(location)
743
Branch.initialize(location)
1060
if existing_bzrdir.has_branch():
1061
if (isinstance(to_transport, LocalTransport)
1062
and not existing_bzrdir.has_workingtree()):
1063
raise errors.BranchExistsWithoutWorkingTree(location)
1064
raise errors.AlreadyBranchError(location)
1065
else:
1066
existing_bzrdir.create_branch()
1067
existing_bzrdir.create_workingtree()
1068
1069
1070
class cmd_init_repository(Command):
1071
"""Create a shared repository to hold branches.
1072
1073
New branches created under the repository directory will store their revisions
1074
in the repository, not in the branch directory, if the branch format supports
1075
shared storage.
1076
1077
example:
1078
bzr init-repo repo
1079
bzr init repo/trunk
1080
bzr checkout --lightweight repo/trunk trunk-checkout
1081
cd trunk-checkout
1082
(add files here)
1083
"""
1084
takes_args = ["location"]
1085
takes_options = [Option('format',
1086
help='Specify a format for this repository.'
1087
' Current formats are: default, knit,'
1088
' metaweave and weave. Default is knit;'
1089
' metaweave and weave are deprecated',
1090
type=get_format_type),
1091
Option('trees',
1092
help='Allows branches in repository to have'
1093
' a working tree')]
1094
aliases = ["init-repo"]
1095
def run(self, location, format=None, trees=False):
1096
if format is None:
1097
format = get_format_type('default')
1098
1099
if location is None:
1100
location = '.'
1101
1102
to_transport = transport.get_transport(location)
1103
try:
1104
to_transport.mkdir('.')
1105
except errors.FileExists:
1106
pass
1107
1108
newdir = format.initialize_on_transport(to_transport)
1109
repo = newdir.create_repository(shared=True)
1110
repo.set_make_working_trees(trees)
744
1111
745
1112
746
1113
class cmd_diff(Command):
747
"""Show differences in working tree.
1114
"""Show differences in the working tree or between revisions.
748
1115
749
1116
If files are listed, only the changes in those files are listed.
750
1117
Otherwise, all changes for the tree are listed.
751
1118
1119
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1120
produces patches suitable for "patch -p1".
1121
752
1122
examples:
753
1123
bzr diff
1124
Shows the difference in the working tree versus the last commit
754
1125
bzr diff -r1
1126
Difference between the working tree and revision 1
755
1127
bzr diff -r1..2
1128
Difference between revision 2 and revision 1
1129
bzr diff --diff-prefix old/:new/
1130
Same as 'bzr diff' but prefix paths with old/ and new/
1131
bzr diff bzr.mine bzr.dev
1132
Show the differences between the two working trees
1133
bzr diff foo.c
1134
Show just the differences for 'foo.c'
756
1135
"""
757
# TODO: Allow diff across branches.
758
1136
# TODO: Option to use external diff command; could be GNU diff, wdiff,
759
1137
# or a graphical diff.
760
1138
761
1139
# TODO: Python difflib is not exactly the same as unidiff; should
762
1140
# either fix it up or prefer to use an external diff.
763
1141
764
# TODO: If a directory is given, diff everything under that.
765
766
1142
# TODO: Selected-file diff is inefficient and doesn't show you
767
1143
# deleted files.
768
1144
769
1145
# TODO: This probably handles non-Unix newlines poorly.
770
1146
771
1147
takes_args = ['file*']
772
takes_options = ['revision', 'diff-options']
1148
takes_options = ['revision', 'diff-options', 'prefix']
773
1149
aliases = ['di', 'dif']
1150
encoding_type = 'exact'
774
1151
775
1152
@display_command
776
def run(self, revision=None, file_list=None, diff_options=None):
777
from bzrlib.diff import show_diff
1153
def run(self, revision=None, file_list=None, diff_options=None,
1154
prefix=None):
1155
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1156
1157
if (prefix is None) or (prefix == '0'):
1158
# diff -p0 format
1159
old_label = ''
1160
new_label = ''
1161
elif prefix == '1':
1162
old_label = 'old/'
1163
new_label = 'new/'
1164
else:
1165
if not ':' in prefix:
1166
raise BzrError("--diff-prefix expects two values separated by a colon")
1167
old_label, new_label = prefix.split(":")
1168
778
1169
try:
779
tree, file_list = internal_tree_files(file_list)
1170
tree1, file_list = internal_tree_files(file_list)
1171
tree2 = None
780
1172
b = None
781
1173
b2 = None
782
1174
except FileInWrongBranch:
783
1175
if len(file_list) != 2:
784
1176
raise BzrCommandError("Files are in different branches")
785
1177
786
b, file1 = Branch.open_containing(file_list[0])
787
b2, file2 = Branch.open_containing(file_list[1])
1178
tree1, file1 = WorkingTree.open_containing(file_list[0])
1179
tree2, file2 = WorkingTree.open_containing(file_list[1])
788
1180
if file1 != "" or file2 != "":
789
1181
# FIXME diff those two files. rbc 20051123
790
1182
raise BzrCommandError("Files are in different branches")
791
1183
file_list = None
1184
except NotBranchError:
1185
if (revision is not None and len(revision) == 2
1186
and not revision[0].needs_branch()
1187
and not revision[1].needs_branch()):
1188
# If both revision specs include a branch, we can
1189
# diff them without needing a local working tree
1190
tree1, tree2 = None, None
1191
else:
1192
raise
792
1193
if revision is not None:
793
if b2 is not None:
1194
if tree2 is not None:
794
1195
raise BzrCommandError("Can't specify -r with two branches")
795
if len(revision) == 1:
796
return show_diff(tree.branch, revision[0], specific_files=file_list,
797
external_diff_options=diff_options)
1196
if (len(revision) == 1) or (revision[1].spec is None):
1197
return diff_cmd_helper(tree1, file_list, diff_options,
1198
revision[0],
1199
old_label=old_label, new_label=new_label)
798
1200
elif len(revision) == 2:
799
return show_diff(tree.branch, revision[0], specific_files=file_list,
800
external_diff_options=diff_options,
801
revision2=revision[1])
1201
return diff_cmd_helper(tree1, file_list, diff_options,
1202
revision[0], revision[1],
1203
old_label=old_label, new_label=new_label)
802
1204
else:
803
1205
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
804
1206
else:
805
if b is not None:
806
return show_diff(b, None, specific_files=file_list,
807
external_diff_options=diff_options, b2=b2)
1207
if tree2 is not None:
1208
return show_diff_trees(tree1, tree2, sys.stdout,
1209
specific_files=file_list,
1210
external_diff_options=diff_options,
1211
old_label=old_label, new_label=new_label)
808
1212
else:
809
return show_diff(tree.branch, None, specific_files=file_list,
810
external_diff_options=diff_options)
1213
return diff_cmd_helper(tree1, file_list, diff_options,
1214
old_label=old_label, new_label=new_label)
811
1215
812
1216
813
1217
class cmd_deleted(Command):
819
1223
# directories with readdir, rather than stating each one. Same
820
1224
# level of effort but possibly much less IO. (Or possibly not,
821
1225
# if the directories are very large...)
1226
takes_options = ['show-ids']
1227
822
1228
@display_command
823
1229
def run(self, show_ids=False):
824
1230
tree = WorkingTree.open_containing(u'.')[0]
825
old = tree.branch.basis_tree()
1231
old = tree.basis_tree()
826
1232
for path, ie in old.inventory.iter_entries():
827
1233
if not tree.has_id(ie.file_id):
1234
self.outf.write(path)
828
1235
if show_ids:
829
print '%-50s %s' % (path, ie.file_id)
830
else:
831
print path
1236
self.outf.write(' ')
1237
self.outf.write(ie.file_id)
1238
self.outf.write('\n')
832
1239
833
1240
834
1241
class cmd_modified(Command):
836
1243
hidden = True
837
1244
@display_command
838
1245
def run(self):
839
from bzrlib.delta import compare_trees
840
841
1246
tree = WorkingTree.open_containing(u'.')[0]
842
td = compare_trees(tree.branch.basis_tree(), tree)
843
1247
td = tree.changes_from(tree.basis_tree())
844
1248
for path, id, kind, text_modified, meta_modified in td.modified:
845
print path
846
1249
self.outf.write(path + '\n')
847
1250
848
1251
849
1252
class cmd_added(Command):
852
1255
@display_command
853
1256
def run(self):
854
1257
wt = WorkingTree.open_containing(u'.')[0]
855
basis_inv = wt.branch.basis_tree().inventory
1258
basis_inv = wt.basis_tree().inventory
856
1259
inv = wt.inventory
857
1260
for file_id in inv:
858
1261
if file_id in basis_inv:
859
1262
continue
860
1263
path = inv.id2path(file_id)
861
if not os.access(b.abspath(path), os.F_OK):
1264
if not os.access(osutils.abspath(path), os.F_OK):
862
1265
continue
863
print path
864
865
1266
self.outf.write(path + '\n')
1267
866
1268
867
1269
class cmd_root(Command):
868
1270
"""Show the tree root directory.
874
1276
def run(self, filename=None):
875
1277
"""Print the branch root."""
876
1278
tree = WorkingTree.open_containing(filename)[0]
877
print tree.basedir
1279
self.outf.write(tree.basedir + '\n')
878
1280
879
1281
880
1282
class cmd_log(Command):
881
"""Show log of this branch.
1283
"""Show log of a branch, file, or directory.
1284
1285
By default show the log of the branch containing the working directory.
882
1286
883
1287
To request a range of logs, you can use the command -r begin..end
884
1288
-r revision requests a specific revision, -r ..end or -r begin.. are
885
1289
also valid.
1290
1291
examples:
1292
bzr log
1293
bzr log foo.c
1294
bzr log -r -10.. http://server/branch
886
1295
"""
887
1296
888
1297
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
889
1298
890
takes_args = ['filename?']
1299
takes_args = ['location?']
891
1300
takes_options = [Option('forward',
892
1301
help='show from oldest to newest'),
893
'timezone', 'verbose',
1302
'timezone',
1303
Option('verbose',
1304
help='show files changed in each revision'),
894
1305
'show-ids', 'revision',
1306
'log-format',
895
1307
'line', 'long',
896
1308
Option('message',
897
1309
help='show revisions whose message matches this regexp',
898
1310
type=str),
899
1311
'short',
900
1312
]
1313
encoding_type = 'replace'
1314
901
1315
@display_command
902
def run(self, filename=None, timezone='original',
1316
def run(self, location=None, timezone='original',
903
1317
verbose=False,
904
1318
show_ids=False,
905
1319
forward=False,
906
1320
revision=None,
1321
log_format=None,
907
1322
message=None,
908
1323
long=False,
909
1324
short=False,
910
1325
line=False):
911
1326
from bzrlib.log import log_formatter, show_log
912
import codecs
913
1327
assert message is None or isinstance(message, basestring), \
914
1328
"invalid message argument %r" % message
915
1329
direction = (forward and 'forward') or 'reverse'
916
1330
917
if filename:
918
# might be a tree:
919
tree = None
920
try:
921
tree, fp = WorkingTree.open_containing(filename)
922
b = tree.branch
923
if fp != '':
924
inv = tree.read_working_inventory()
925
except NotBranchError:
926
pass
927
if tree is None:
928
b, fp = Branch.open_containing(filename)
929
if fp != '':
930
inv = b.get_inventory(b.last_revision())
1331
# log everything
1332
file_id = None
1333
if location:
1334
# find the file id to log:
1335
1336
dir, fp = bzrdir.BzrDir.open_containing(location)
1337
b = dir.open_branch()
931
1338
if fp != '':
1339
try:
1340
# might be a tree:
1341
inv = dir.open_workingtree().inventory
1342
except (errors.NotBranchError, errors.NotLocalUrl):
1343
# either no tree, or is remote.
1344
inv = b.basis_tree().inventory
932
1345
file_id = inv.path2id(fp)
933
else:
934
file_id = None # points to branch root
935
1346
else:
936
tree, relpath = WorkingTree.open_containing(u'.')
937
b = tree.branch
938
file_id = None
1347
# local dir only
1348
# FIXME ? log the current subdir only RBC 20060203
1349
dir, relpath = bzrdir.BzrDir.open_containing('.')
1350
b = dir.open_branch()
939
1351
940
1352
if revision is None:
941
1353
rev1 = None
943
1355
elif len(revision) == 1:
944
1356
rev1 = rev2 = revision[0].in_history(b).revno
945
1357
elif len(revision) == 2:
946
rev1 = revision[0].in_history(b).revno
947
rev2 = revision[1].in_history(b).revno
1358
if revision[0].spec is None:
1359
# missing begin-range means first revision
1360
rev1 = 1
1361
else:
1362
rev1 = revision[0].in_history(b).revno
1363
1364
if revision[1].spec is None:
1365
# missing end-range means last known revision
1366
rev2 = b.revno()
1367
else:
1368
rev2 = revision[1].in_history(b).revno
948
1369
else:
949
1370
raise BzrCommandError('bzr log --revision takes one or two values.')
950
1371
954
1375
if rev1 > rev2:
955
1376
(rev2, rev1) = (rev1, rev2)
956
1377
957
mutter('encoding log as %r', bzrlib.user_encoding)
958
959
# use 'replace' so that we don't abort if trying to write out
960
# in e.g. the default C locale.
961
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
962
963
log_format = get_log_format(long=long, short=short, line=line)
1378
if (log_format == None):
1379
default = b.get_config().log_format()
1380
log_format = get_log_format(long=long, short=short, line=line,
1381
default=default)
964
1382
lf = log_formatter(log_format,
965
1383
show_ids=show_ids,
966
to_file=outf,
1384
to_file=self.outf,
967
1385
show_timezone=timezone)
968
1386
969
1387
show_log(b,
975
1393
end_revision=rev2,
976
1394
search=message)
977
1395
1396
978
1397
def get_log_format(long=False, short=False, line=False, default='long'):
979
1398
log_format = default
980
1399
if long:
989
1408
class cmd_touching_revisions(Command):
990
1409
"""Return revision-ids which affected a particular file.
991
1410
992
A more user-friendly interface is "bzr log FILE"."""
1411
A more user-friendly interface is "bzr log FILE".
1412
"""
1413
993
1414
hidden = True
994
1415
takes_args = ["filename"]
1416
995
1417
@display_command
996
1418
def run(self, filename):
997
1419
tree, relpath = WorkingTree.open_containing(filename)
998
1420
b = tree.branch
999
1421
inv = tree.read_working_inventory()
1000
1422
file_id = inv.path2id(relpath)
1001
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1002
print "%6d %s" % (revno, what)
1423
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1424
self.outf.write("%6d %s\n" % (revno, what))
1003
1425
1004
1426
1005
1427
class cmd_ls(Command):
1036
1458
elif relpath:
1037
1459
relpath += '/'
1038
1460
if revision is not None:
1039
tree = tree.branch.revision_tree(
1461
tree = tree.branch.repository.revision_tree(
1040
1462
revision[0].in_history(tree.branch).rev_id)
1463
1041
1464
for fp, fc, kind, fid, entry in tree.list_files():
1042
1465
if fp.startswith(relpath):
1043
1466
fp = fp[len(relpath):]
1047
1470
continue
1048
1471
if verbose:
1049
1472
kindch = entry.kind_character()
1050
print '%-8s %s%s' % (fc, fp, kindch)
1473
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1051
1474
elif null:
1052
sys.stdout.write(fp)
1053
sys.stdout.write('\0')
1054
sys.stdout.flush()
1475
self.outf.write(fp + '\0')
1476
self.outf.flush()
1055
1477
else:
1056
print fp
1478
self.outf.write(fp + '\n')
1057
1479
1058
1480
1059
1481
class cmd_unknowns(Command):
1060
1482
"""List unknown files."""
1061
1483
@display_command
1062
1484
def run(self):
1063
from bzrlib.osutils import quotefn
1064
1485
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1065
print quotefn(f)
1486
self.outf.write(osutils.quotefn(f) + '\n')
1066
1487
1067
1488
1068
1489
class cmd_ignore(Command):
1084
1505
bzr ignore '*.class'
1085
1506
"""
1086
1507
# TODO: Complain if the filename is absolute
1087
takes_args = ['name_pattern']
1508
takes_args = ['name_pattern?']
1509
takes_options = [
1510
Option('old-default-rules',
1511
help='Out the ignore rules bzr < 0.9 always used.')
1512
]
1088
1513
1089
def run(self, name_pattern):
1514
def run(self, name_pattern=None, old_default_rules=None):
1090
1515
from bzrlib.atomicfile import AtomicFile
1091
import os.path
1092
1516
if old_default_rules is not None:
1517
# dump the rules and exit
1518
for pattern in ignores.OLD_DEFAULTS:
1519
print pattern
1520
return
1521
if name_pattern is None:
1522
raise BzrCommandError("ignore requires a NAME_PATTERN")
1093
1523
tree, relpath = WorkingTree.open_containing(u'.')
1094
1524
ifn = tree.abspath('.bzrignore')
1095
1096
1525
if os.path.exists(ifn):
1097
1526
f = open(ifn, 'rt')
1098
1527
try:
1109
1538
igns += '\n'
1110
1539
igns += name_pattern + '\n'
1111
1540
1541
f = AtomicFile(ifn, 'wt')
1112
1542
try:
1113
f = AtomicFile(ifn, 'wt')
1114
1543
f.write(igns.encode('utf-8'))
1115
1544
f.commit()
1116
1545
finally:
1172
1601
1173
1602
Note: export of tree with non-ascii filenames to zip is not supported.
1174
1603
1175
Supported formats Autodetected by extension
1176
----------------- -------------------------
1604
Supported formats Autodetected by extension
1605
----------------- -------------------------
1177
1606
dir -
1178
1607
tar .tar
1179
1608
tbz2 .tar.bz2, .tbz2
1183
1612
takes_args = ['dest']
1184
1613
takes_options = ['revision', 'format', 'root']
1185
1614
def run(self, dest, revision=None, format=None, root=None):
1186
import os.path
1187
1615
from bzrlib.export import export
1188
1616
tree = WorkingTree.open_containing(u'.')[0]
1189
1617
b = tree.branch
1194
1622
if len(revision) != 1:
1195
1623
raise BzrError('bzr export --revision takes exactly 1 argument')
1196
1624
rev_id = revision[0].in_history(b).rev_id
1197
t = b.revision_tree(rev_id)
1625
t = b.repository.revision_tree(rev_id)
1198
1626
try:
1199
1627
export(t, dest, format, root)
1200
1628
except errors.NoSuchExportFormat, e:
1232
1660
hidden = True
1233
1661
@display_command
1234
1662
def run(self):
1235
print bzrlib.osutils.local_time_offset()
1663
print osutils.local_time_offset()
1236
1664
1237
1665
1238
1666
1268
1696
Option('strict',
1269
1697
help="refuse to commit if there are unknown "
1270
1698
"files in the working tree."),
1699
Option('local',
1700
help="perform a local only commit in a bound "
1701
"branch. Such commits are not pushed to "
1702
"the master branch until a normal commit "
1703
"is performed."
1704
),
1271
1705
]
1272
1706
aliases = ['ci', 'checkin']
1273
1707
1274
1708
def run(self, message=None, file=None, verbose=True, selected_list=None,
1275
unchanged=False, strict=False):
1709
unchanged=False, strict=False, local=False):
1710
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1276
1711
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1277
1712
StrictCommitFailed)
1278
1713
from bzrlib.msgeditor import edit_commit_message, \
1279
1714
make_commit_message_template
1280
from bzrlib.status import show_status
1281
1715
from tempfile import TemporaryFile
1282
import codecs
1283
1716
1284
1717
# TODO: Need a blackbox test for invoking the external editor; may be
1285
1718
# slightly problematic to run this cross-platform.
1290
1723
# TODO: if the commit *does* happen to fail, then save the commit
1291
1724
# message to a temporary file where it can be recovered
1292
1725
tree, selected_list = tree_files(selected_list)
1726
if selected_list == ['']:
1727
# workaround - commit of root of tree should be exactly the same
1728
# as just default commit in that tree, and succeed even though
1729
# selected-file merge commit is not done yet
1730
selected_list = []
1731
1732
if local and not tree.branch.get_bound_location():
1733
raise errors.LocalRequiresBoundBranch()
1293
1734
if message is None and not file:
1294
1735
template = make_commit_message_template(tree, selected_list)
1295
1736
message = edit_commit_message(template)
1300
1741
raise BzrCommandError("please specify either --message or --file")
1301
1742
1302
1743
if file:
1303
import codecs
1304
1744
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1305
1745
1306
1746
if message == "":
1307
raise BzrCommandError("empty commit message specified")
1308
1747
raise BzrCommandError("empty commit message specified")
1748
1749
if verbose:
1750
reporter = ReportCommitToLog()
1751
else:
1752
reporter = NullCommitReporter()
1753
1309
1754
try:
1310
1755
tree.commit(message, specific_files=selected_list,
1311
allow_pointless=unchanged, strict=strict)
1756
allow_pointless=unchanged, strict=strict, local=local,
1757
reporter=reporter)
1312
1758
except PointlessCommit:
1313
1759
# FIXME: This should really happen before the file is read in;
1314
1760
# perhaps prepare the commit; get the message; then actually commit
1315
raise BzrCommandError("no changes to commit",
1316
["use --unchanged to commit anyhow"])
1761
raise BzrCommandError("no changes to commit."
1762
" use --unchanged to commit anyhow")
1317
1763
except ConflictsInTree:
1318
1764
raise BzrCommandError("Conflicts detected in working tree. "
1319
1765
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1320
1766
except StrictCommitFailed:
1321
1767
raise BzrCommandError("Commit refused because there are unknown "
1322
1768
"files in the working tree.")
1323
note('Committed revision %d.' % (tree.branch.revno(),))
1324
1769
except errors.BoundBranchOutOfDate, e:
1770
raise BzrCommandError(str(e) + "\n"
1771
'To commit to master branch, run update and then commit.\n'
1772
'You can also pass --local to commit to continue working '
1773
'disconnected.')
1325
1774
1326
1775
class cmd_check(Command):
1327
1776
"""Validate consistency of branch history.
1359
1808
1360
1809
if c.needs_write:
1361
1810
c.write()
1362
1363
1811
1364
1812
1365
1813
class cmd_upgrade(Command):
1366
1814
"""Upgrade branch storage to current format.
1367
1815
1368
1816
The check command or bzr developers may sometimes advise you to run
1369
this command.
1370
1371
This version of this command upgrades from the full-text storage
1372
used by bzr 0.0.8 and earlier to the weave format (v5).
1817
this command. When the default format has changed you may also be warned
1818
during other operations to upgrade.
1373
1819
"""
1374
takes_args = ['dir?']
1375
1376
def run(self, dir=u'.'):
1820
takes_args = ['url?']
1821
takes_options = [
1822
Option('format',
1823
help='Upgrade to a specific format. Current formats'
1824
' are: default, knit, metaweave and weave.'
1825
' Default is knit; metaweave and weave are'
1826
' deprecated',
1827
type=get_format_type),
1828
]
1829
1830
1831
def run(self, url='.', format=None):
1377
1832
from bzrlib.upgrade import upgrade
1378
upgrade(dir)
1833
if format is None:
1834
format = get_format_type('default')
1835
upgrade(url, format)
1379
1836
1380
1837
1381
1838
class cmd_whoami(Command):
1382
"""Show bzr user id."""
1383
takes_options = ['email']
1839
"""Show or set bzr user id.
1840
1841
examples:
1842
bzr whoami --email
1843
bzr whoami 'Frank Chu <fchu@example.com>'
1844
"""
1845
takes_options = [ Option('email',
1846
help='display email address only'),
1847
Option('branch',
1848
help='set identity for the current branch instead of '
1849
'globally'),
1850
]
1851
takes_args = ['name?']
1852
encoding_type = 'replace'
1384
1853
1385
1854
@display_command
1386
def run(self, email=False):
1855
def run(self, email=False, branch=False, name=None):
1856
if name is None:
1857
# use branch if we're inside one; otherwise global config
1858
try:
1859
c = Branch.open_containing('.')[0].get_config()
1860
except NotBranchError:
1861
c = config.GlobalConfig()
1862
if email:
1863
self.outf.write(c.user_email() + '\n')
1864
else:
1865
self.outf.write(c.username() + '\n')
1866
return
1867
1868
# display a warning if an email address isn't included in the given name.
1387
1869
try:
1388
b = WorkingTree.open_containing(u'.')[0].branch
1389
config = bzrlib.config.BranchConfig(b)
1390
except NotBranchError:
1391
config = bzrlib.config.GlobalConfig()
1870
config.extract_email_address(name)
1871
except BzrError, e:
1872
warning('"%s" does not seem to contain an email address. '
1873
'This is allowed, but not recommended.', name)
1392
1874
1393
if email:
1394
print config.user_email()
1875
# use global config unless --branch given
1876
if branch:
1877
c = Branch.open_containing('.')[0].get_config()
1395
1878
else:
1396
print config.username()
1879
c = config.GlobalConfig()
1880
c.set_user_option('email', name)
1881
1397
1882
1398
1883
class cmd_nick(Command):
1399
"""\
1400
Print or set the branch nickname.
1884
"""Print or set the branch nickname.
1885
1401
1886
If unset, the tree root directory name is used as the nickname
1402
1887
To print the current nickname, execute with no argument.
1403
1888
"""
1413
1898
def printme(self, branch):
1414
1899
print branch.nick
1415
1900
1901
1416
1902
class cmd_selftest(Command):
1417
1903
"""Run internal test suite.
1418
1904
1423
1909
1424
1910
If arguments are given, they are regular expressions that say
1425
1911
which tests should run.
1912
1913
If the global option '--no-plugins' is given, plugins are not loaded
1914
before running the selftests. This has two effects: features provided or
1915
modified by plugins will not be tested, and tests provided by plugins will
1916
not be run.
1917
1918
examples:
1919
bzr selftest ignore
1920
bzr --no-plugins selftest -v
1426
1921
"""
1427
1922
# TODO: --list should give a list of all available tests
1923
1924
# NB: this is used from the class without creating an instance, which is
1925
# why it does not have a self parameter.
1926
def get_transport_type(typestring):
1927
"""Parse and return a transport specifier."""
1928
if typestring == "sftp":
1929
from bzrlib.transport.sftp import SFTPAbsoluteServer
1930
return SFTPAbsoluteServer
1931
if typestring == "memory":
1932
from bzrlib.transport.memory import MemoryServer
1933
return MemoryServer
1934
if typestring == "fakenfs":
1935
from bzrlib.transport.fakenfs import FakeNFSServer
1936
return FakeNFSServer
1937
msg = "No known transport type %s. Supported types are: sftp\n" %\
1938
(typestring)
1939
raise BzrCommandError(msg)
1940
1428
1941
hidden = True
1429
1942
takes_args = ['testspecs*']
1430
takes_options = ['verbose',
1943
takes_options = ['verbose',
1431
1944
Option('one', help='stop when one test fails'),
1432
1945
Option('keep-output',
1433
help='keep output directories when tests fail')
1434
]
1946
help='keep output directories when tests fail'),
1947
Option('transport',
1948
help='Use a different transport by default '
1949
'throughout the test suite.',
1950
type=get_transport_type),
1951
Option('benchmark', help='run the bzr bencharks.'),
1952
Option('lsprof-timed',
1953
help='generate lsprof output for benchmarked'
1954
' sections of code.'),
1955
Option('cache-dir', type=str,
1956
help='a directory to cache intermediate'
1957
' benchmark steps'),
1958
]
1435
1959
1436
def run(self, testspecs_list=None, verbose=False, one=False,
1437
keep_output=False):
1960
def run(self, testspecs_list=None, verbose=None, one=False,
1961
keep_output=False, transport=None, benchmark=None,
1962
lsprof_timed=None, cache_dir=None):
1438
1963
import bzrlib.ui
1439
1964
from bzrlib.tests import selftest
1965
import bzrlib.benchmarks as benchmarks
1966
from bzrlib.benchmarks import tree_creator
1967
1968
if cache_dir is not None:
1969
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
1440
1970
# we don't want progress meters from the tests to go to the
1441
1971
# real output; and we don't want log messages cluttering up
1442
1972
# the real logs.
1443
save_ui = bzrlib.ui.ui_factory
1444
bzrlib.trace.info('running tests...')
1973
save_ui = ui.ui_factory
1974
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1975
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1976
print
1977
info('running tests...')
1445
1978
try:
1446
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1979
ui.ui_factory = ui.SilentUIFactory()
1447
1980
if testspecs_list is not None:
1448
1981
pattern = '|'.join(testspecs_list)
1449
1982
else:
1450
1983
pattern = ".*"
1451
result = selftest(verbose=verbose,
1452
pattern=pattern,
1453
stop_on_failure=one,
1454
keep_output=keep_output)
1984
if benchmark:
1985
test_suite_factory = benchmarks.test_suite
1986
if verbose is None:
1987
verbose = True
1988
benchfile = open(".perf_history", "at")
1989
else:
1990
test_suite_factory = None
1991
if verbose is None:
1992
verbose = False
1993
benchfile = None
1994
try:
1995
result = selftest(verbose=verbose,
1996
pattern=pattern,
1997
stop_on_failure=one,
1998
keep_output=keep_output,
1999
transport=transport,
2000
test_suite_factory=test_suite_factory,
2001
lsprof_timed=lsprof_timed,
2002
bench_history=benchfile)
2003
finally:
2004
if benchfile is not None:
2005
benchfile.close()
1455
2006
if result:
1456
bzrlib.trace.info('tests passed')
2007
info('tests passed')
1457
2008
else:
1458
bzrlib.trace.info('tests failed')
2009
info('tests failed')
1459
2010
return int(not result)
1460
2011
finally:
1461
bzrlib.ui.ui_factory = save_ui
1462
1463
1464
def _get_bzr_branch():
1465
"""If bzr is run from a branch, return Branch or None"""
1466
import bzrlib.errors
1467
from bzrlib.branch import Branch
1468
from bzrlib.osutils import abspath
1469
from os.path import dirname
1470
1471
try:
1472
branch = Branch.open(dirname(abspath(dirname(__file__))))
1473
return branch
1474
except bzrlib.errors.BzrError:
1475
return None
1476
1477
1478
def show_version():
1479
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1480
# is bzrlib itself in a branch?
1481
branch = _get_bzr_branch()
1482
if branch:
1483
rh = branch.revision_history()
1484
revno = len(rh)
1485
print " bzr checkout, revision %d" % (revno,)
1486
print " nick: %s" % (branch.nick,)
1487
if rh:
1488
print " revid: %s" % (rh[-1],)
1489
print bzrlib.__copyright__
1490
print "http://bazaar-ng.org/"
1491
print
1492
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1493
print "you may use, modify and redistribute it under the terms of the GNU"
1494
print "General Public License version 2 or later."
2012
ui.ui_factory = save_ui
1495
2013
1496
2014
1497
2015
class cmd_version(Command):
1498
2016
"""Show version of bzr."""
2017
1499
2018
@display_command
1500
2019
def run(self):
2020
from bzrlib.version import show_version
1501
2021
show_version()
1502
2022
2023
1503
2024
class cmd_rocks(Command):
1504
2025
"""Statement of optimism."""
2026
1505
2027
hidden = True
2028
1506
2029
@display_command
1507
2030
def run(self):
1508
2031
print "it sure does!"
1509
2032
1510
2033
1511
2034
class cmd_find_merge_base(Command):
1512
"""Find and print a base revision for merging two branches.
1513
"""
2035
"""Find and print a base revision for merging two branches."""
1514
2036
# TODO: Options to specify revisions on either side, as if
1515
2037
# merging only part of the history.
1516
2038
takes_args = ['branch', 'other']
1529
2051
last1 = branch1.last_revision()
1530
2052
last2 = branch2.last_revision()
1531
2053
1532
source = MultipleRevisionSources(branch1, branch2)
2054
source = MultipleRevisionSources(branch1.repository,
2055
branch2.repository)
1533
2056
1534
2057
base_rev_id = common_ancestor(last1, last2, source)
1535
2058
1536
2059
print 'merge base is revision %s' % base_rev_id
1537
1538
return
1539
1540
if base_revno is None:
1541
raise bzrlib.errors.UnrelatedBranches()
1542
1543
print ' r%-6d in %s' % (base_revno, branch)
1544
1545
other_revno = branch2.revision_id_to_revno(base_revid)
1546
1547
print ' r%-6d in %s' % (other_revno, other)
1548
1549
2060
1550
2061
1551
2062
class cmd_merge(Command):
1552
2063
"""Perform a three-way merge.
1553
2064
1554
The branch is the branch you will merge from. By default, it will
1555
merge the latest revision. If you specify a revision, that
1556
revision will be merged. If you specify two revisions, the first
1557
will be used as a BASE, and the second one as OTHER. Revision
1558
numbers are always relative to the specified branch.
2065
The branch is the branch you will merge from. By default, it will merge
2066
the latest revision. If you specify a revision, that revision will be
2067
merged. If you specify two revisions, the first will be used as a BASE,
2068
and the second one as OTHER. Revision numbers are always relative to the
2069
specified branch.
1559
2070
1560
By default bzr will try to merge in all new work from the other
2071
By default, bzr will try to merge in all new work from the other
1561
2072
branch, automatically determining an appropriate base. If this
1562
2073
fails, you may need to give an explicit base.
1563
2074
2075
Merge will do its best to combine the changes in two branches, but there
2076
are some kinds of problems only a human can fix. When it encounters those,
2077
it will mark a conflict. A conflict means that you need to fix something,
2078
before you should commit.
2079
2080
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2081
2082
If there is no default branch set, the first merge will set it. After
2083
that, you can omit the branch to use the default. To change the
2084
default, use --remember. The value will only be saved if the remote
2085
location can be accessed.
2086
1564
2087
Examples:
1565
2088
1566
2089
To merge the latest revision from bzr.dev
1574
2097
1575
2098
merge refuses to run if there are any uncommitted changes, unless
1576
2099
--force is given.
2100
2101
The following merge types are available:
1577
2102
"""
1578
2103
takes_args = ['branch?']
1579
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
2104
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1580
2105
Option('show-base', help="Show base revision text in "
1581
"conflicts")]
2106
"conflicts"),
2107
Option('uncommitted', help='Apply uncommitted changes'
2108
' from a working copy, instead of branch changes')]
2109
2110
def help(self):
2111
from merge import merge_type_help
2112
from inspect import getdoc
2113
return getdoc(self) + '\n' + merge_type_help()
1582
2114
1583
2115
def run(self, branch=None, revision=None, force=False, merge_type=None,
1584
show_base=False, reprocess=False):
1585
from bzrlib.merge import merge
1586
from bzrlib.merge_core import ApplyMerge3
2116
show_base=False, reprocess=False, remember=False,
2117
uncommitted=False):
1587
2118
if merge_type is None:
1588
merge_type = ApplyMerge3
1589
if branch is None:
1590
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1591
if branch is None:
1592
raise BzrCommandError("No merge location known or specified.")
2119
merge_type = Merge3Merger
2120
2121
tree = WorkingTree.open_containing(u'.')[0]
2122
2123
if branch is not None:
2124
try:
2125
reader = bundle.read_bundle_from_url(branch)
2126
except NotABundle:
2127
pass # Continue on considering this url a Branch
1593
2128
else:
1594
print "Using saved location: %s" % branch
2129
conflicts = merge_bundle(reader, tree, not force, merge_type,
2130
reprocess, show_base)
2131
if conflicts == 0:
2132
return 0
2133
else:
2134
return 1
2135
2136
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2137
1595
2138
if revision is None or len(revision) < 1:
1596
base = [None, None]
1597
other = [branch, -1]
2139
if uncommitted:
2140
base = [branch, -1]
2141
other = [branch, None]
2142
else:
2143
base = [None, None]
2144
other = [branch, -1]
2145
other_branch, path = Branch.open_containing(branch)
1598
2146
else:
2147
if uncommitted:
2148
raise BzrCommandError('Cannot use --uncommitted and --revision'
2149
' at the same time.')
1599
2150
if len(revision) == 1:
1600
2151
base = [None, None]
1601
other_branch = Branch.open_containing(branch)[0]
2152
other_branch, path = Branch.open_containing(branch)
1602
2153
revno = revision[0].in_history(other_branch).revno
1603
2154
other = [branch, revno]
1604
2155
else:
1606
2157
if None in revision:
1607
2158
raise BzrCommandError(
1608
2159
"Merge doesn't permit that revision specifier.")
1609
b = Branch.open_containing(branch)[0]
1610
1611
base = [branch, revision[0].in_history(b).revno]
1612
other = [branch, revision[1].in_history(b).revno]
1613
2160
other_branch, path = Branch.open_containing(branch)
2161
2162
base = [branch, revision[0].in_history(other_branch).revno]
2163
other = [branch, revision[1].in_history(other_branch).revno]
2164
2165
if tree.branch.get_parent() is None or remember:
2166
tree.branch.set_parent(other_branch.base)
2167
2168
if path != "":
2169
interesting_files = [path]
2170
else:
2171
interesting_files = None
2172
pb = ui.ui_factory.nested_progress_bar()
1614
2173
try:
1615
conflict_count = merge(other, base, check_clean=(not force),
1616
merge_type=merge_type, reprocess=reprocess,
1617
show_base=show_base)
2174
try:
2175
conflict_count = merge(other, base, check_clean=(not force),
2176
merge_type=merge_type,
2177
reprocess=reprocess,
2178
show_base=show_base,
2179
pb=pb, file_list=interesting_files)
2180
finally:
2181
pb.finished()
1618
2182
if conflict_count != 0:
1619
2183
return 1
1620
2184
else:
1621
2185
return 0
1622
except bzrlib.errors.AmbiguousBase, e:
2186
except errors.AmbiguousBase, e:
1623
2187
m = ("sorry, bzr can't determine the right merge base yet\n"
1624
2188
"candidates are:\n "
1625
2189
+ "\n ".join(e.bases)
1628
2192
"and (if you want) report this to the bzr developers\n")
1629
2193
log_error(m)
1630
2194
2195
# TODO: move up to common parent; this isn't merge-specific anymore.
2196
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2197
"""Use tree.branch's parent if none was supplied.
2198
2199
Report if the remembered location was used.
2200
"""
2201
if supplied_location is not None:
2202
return supplied_location
2203
stored_location = tree.branch.get_parent()
2204
mutter("%s", stored_location)
2205
if stored_location is None:
2206
raise BzrCommandError("No location specified or remembered")
2207
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2208
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2209
return stored_location
2210
1631
2211
1632
2212
class cmd_remerge(Command):
1633
2213
"""Redo a merge.
1634
"""
2214
2215
Use this if you want to try a different merge technique while resolving
2216
conflicts. Some merge techniques are better than others, and remerge
2217
lets you try different ones on different files.
2218
2219
The options for remerge have the same meaning and defaults as the ones for
2220
merge. The difference is that remerge can (only) be run when there is a
2221
pending merge, and it lets you specify particular files.
2222
2223
Examples:
2224
$ bzr remerge --show-base
2225
Re-do the merge of all conflicted files, and show the base text in
2226
conflict regions, in addition to the usual THIS and OTHER texts.
2227
2228
$ bzr remerge --merge-type weave --reprocess foobar
2229
Re-do the merge of "foobar", using the weave merge algorithm, with
2230
additional processing to reduce the size of conflict regions.
2231
2232
The following merge types are available:"""
1635
2233
takes_args = ['file*']
1636
2234
takes_options = ['merge-type', 'reprocess',
1637
2235
Option('show-base', help="Show base revision text in "
1638
2236
"conflicts")]
1639
2237
2238
def help(self):
2239
from merge import merge_type_help
2240
from inspect import getdoc
2241
return getdoc(self) + '\n' + merge_type_help()
2242
1640
2243
def run(self, file_list=None, merge_type=None, show_base=False,
1641
2244
reprocess=False):
1642
2245
from bzrlib.merge import merge_inner, transform_tree
1643
from bzrlib.merge_core import ApplyMerge3
1644
2246
if merge_type is None:
1645
merge_type = ApplyMerge3
2247
merge_type = Merge3Merger
1646
2248
tree, file_list = tree_files(file_list)
1647
2249
tree.lock_write()
1648
2250
try:
1649
pending_merges = tree.pending_merges()
1650
if len(pending_merges) != 1:
2251
parents = tree.get_parent_ids()
2252
if len(parents) != 2:
1651
2253
raise BzrCommandError("Sorry, remerge only works after normal"
1652
+ " merges. Not cherrypicking or"
1653
+ "multi-merges.")
1654
base_revision = common_ancestor(tree.branch.last_revision(),
1655
pending_merges[0], tree.branch)
1656
base_tree = tree.branch.revision_tree(base_revision)
1657
other_tree = tree.branch.revision_tree(pending_merges[0])
2254
" merges. Not cherrypicking or"
2255
" multi-merges.")
2256
repository = tree.branch.repository
2257
base_revision = common_ancestor(parents[0],
2258
parents[1], repository)
2259
base_tree = repository.revision_tree(base_revision)
2260
other_tree = repository.revision_tree(parents[1])
1658
2261
interesting_ids = None
2262
new_conflicts = []
2263
conflicts = tree.conflicts()
1659
2264
if file_list is not None:
1660
2265
interesting_ids = set()
1661
2266
for filename in file_list:
1662
2267
file_id = tree.path2id(filename)
2268
if file_id is None:
2269
raise NotVersionedError(filename)
1663
2270
interesting_ids.add(file_id)
1664
2271
if tree.kind(file_id) != "directory":
1665
2272
continue
1666
2273
1667
2274
for name, ie in tree.inventory.iter_entries(file_id):
1668
2275
interesting_ids.add(ie.file_id)
1669
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
2276
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2277
transform_tree(tree, tree.basis_tree(), interesting_ids)
2278
tree.set_conflicts(ConflictList(new_conflicts))
1670
2279
if file_list is None:
1671
2280
restore_files = list(tree.iter_conflicts())
1672
2281
else:
1676
2285
restore(tree.abspath(filename))
1677
2286
except NotConflicted:
1678
2287
pass
1679
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1680
interesting_ids = interesting_ids,
1681
other_rev_id=pending_merges[0],
1682
merge_type=merge_type,
1683
show_base=show_base,
1684
reprocess=reprocess)
2288
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2289
this_tree=tree,
2290
interesting_ids=interesting_ids,
2291
other_rev_id=parents[1],
2292
merge_type=merge_type,
2293
show_base=show_base,
2294
reprocess=reprocess)
1685
2295
finally:
1686
2296
tree.unlock()
1687
2297
if conflicts > 0:
1701
2311
aliases = ['merge-revert']
1702
2312
1703
2313
def run(self, revision=None, no_backup=False, file_list=None):
1704
from bzrlib.merge import merge_inner
1705
2314
from bzrlib.commands import parse_spec
1706
2315
if file_list is not None:
1707
2316
if len(file_list) == 0:
1708
2317
raise BzrCommandError("No files specified")
1709
2318
else:
1710
2319
file_list = []
2320
2321
tree, file_list = tree_files(file_list)
1711
2322
if revision is None:
1712
revno = -1
1713
tree = WorkingTree.open_containing(u'.')[0]
1714
2323
# FIXME should be tree.last_revision
1715
rev_id = tree.branch.last_revision()
2324
rev_id = tree.last_revision()
1716
2325
elif len(revision) != 1:
1717
2326
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1718
2327
else:
1719
tree, file_list = tree_files(file_list)
1720
2328
rev_id = revision[0].in_history(tree.branch).rev_id
1721
tree.revert(file_list, tree.branch.revision_tree(rev_id),
1722
not no_backup)
2329
pb = ui.ui_factory.nested_progress_bar()
2330
try:
2331
tree.revert(file_list,
2332
tree.branch.repository.revision_tree(rev_id),
2333
not no_backup, pb)
2334
finally:
2335
pb.finished()
1723
2336
1724
2337
1725
2338
class cmd_assert_fail(Command):
1733
2346
"""Show help on a command or other topic.
1734
2347
1735
2348
For a list of all available commands, say 'bzr help commands'."""
1736
takes_options = ['long']
2349
takes_options = [Option('long', 'show help on all commands')]
1737
2350
takes_args = ['topic?']
1738
aliases = ['?']
2351
aliases = ['?', '--help', '-?', '-h']
1739
2352
1740
2353
@display_command
1741
2354
def run(self, topic=None, long=False):
1767
2380
takes_args = ['from_branch', 'to_branch']
1768
2381
def run(self, from_branch, to_branch):
1769
2382
from bzrlib.fetch import Fetcher
1770
from bzrlib.branch import Branch
1771
2383
from_b = Branch.open(from_branch)
1772
2384
to_b = Branch.open(to_branch)
1773
from_b.lock_read()
1774
try:
1775
to_b.lock_write()
1776
try:
1777
Fetcher(to_b, from_b)
1778
finally:
1779
to_b.unlock()
1780
finally:
1781
from_b.unlock()
2385
Fetcher(to_b, from_b)
1782
2386
1783
2387
1784
2388
class cmd_missing(Command):
1791
2395
'Display changes in the local branch only'),
1792
2396
Option('theirs-only',
1793
2397
'Display changes in the remote branch only'),
2398
'log-format',
1794
2399
'line',
1795
2400
'long',
1796
2401
'short',
1797
2402
'show-ids',
1798
2403
'verbose'
1799
2404
]
2405
encoding_type = 'replace'
1800
2406
2407
@display_command
1801
2408
def run(self, other_branch=None, reverse=False, mine_only=False,
1802
theirs_only=False, long=True, short=False, line=False,
2409
theirs_only=False, log_format=None, long=False, short=False, line=False,
1803
2410
show_ids=False, verbose=False):
1804
2411
from bzrlib.missing import find_unmerged, iter_log_data
1805
2412
from bzrlib.log import log_formatter
1806
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2413
local_branch = Branch.open_containing(u".")[0]
1807
2414
parent = local_branch.get_parent()
1808
2415
if other_branch is None:
1809
2416
other_branch = parent
1810
2417
if other_branch is None:
1811
raise BzrCommandError("No missing location known or specified.")
2418
raise BzrCommandError("No peer location known or specified.")
1812
2419
print "Using last location: " + local_branch.get_parent()
1813
remote_branch = bzrlib.branch.Branch.open(other_branch)
1814
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1815
log_format = get_log_format(long=long, short=short, line=line)
1816
lf = log_formatter(log_format, sys.stdout,
1817
show_ids=show_ids,
1818
show_timezone='original')
1819
if reverse is False:
1820
local_extra.reverse()
1821
remote_extra.reverse()
1822
if local_extra and not theirs_only:
1823
print "You have %d extra revision(s):" % len(local_extra)
1824
for data in iter_log_data(local_extra, local_branch, verbose):
1825
lf.show(*data)
1826
printed_local = True
1827
else:
1828
printed_local = False
1829
if remote_extra and not mine_only:
1830
if printed_local is True:
1831
print "\n\n"
1832
print "You are missing %d revision(s):" % len(remote_extra)
1833
for data in iter_log_data(remote_extra, remote_branch, verbose):
1834
lf.show(*data)
1835
if not remote_extra and not local_extra:
1836
status_code = 0
1837
print "Branches are up to date."
1838
else:
1839
status_code = 1
1840
if parent is None and other_branch is not None:
1841
local_branch.set_parent(other_branch)
2420
remote_branch = Branch.open(other_branch)
2421
if remote_branch.base == local_branch.base:
2422
remote_branch = local_branch
2423
local_branch.lock_read()
2424
try:
2425
remote_branch.lock_read()
2426
try:
2427
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2428
if (log_format == None):
2429
default = local_branch.get_config().log_format()
2430
log_format = get_log_format(long=long, short=short,
2431
line=line, default=default)
2432
lf = log_formatter(log_format,
2433
to_file=self.outf,
2434
show_ids=show_ids,
2435
show_timezone='original')
2436
if reverse is False:
2437
local_extra.reverse()
2438
remote_extra.reverse()
2439
if local_extra and not theirs_only:
2440
print "You have %d extra revision(s):" % len(local_extra)
2441
for data in iter_log_data(local_extra, local_branch.repository,
2442
verbose):
2443
lf.show(*data)
2444
printed_local = True
2445
else:
2446
printed_local = False
2447
if remote_extra and not mine_only:
2448
if printed_local is True:
2449
print "\n\n"
2450
print "You are missing %d revision(s):" % len(remote_extra)
2451
for data in iter_log_data(remote_extra, remote_branch.repository,
2452
verbose):
2453
lf.show(*data)
2454
if not remote_extra and not local_extra:
2455
status_code = 0
2456
print "Branches are up to date."
2457
else:
2458
status_code = 1
2459
finally:
2460
remote_branch.unlock()
2461
finally:
2462
local_branch.unlock()
2463
if not status_code and parent is None and other_branch is not None:
2464
local_branch.lock_write()
2465
try:
2466
# handle race conditions - a parent might be set while we run.
2467
if local_branch.get_parent() is None:
2468
local_branch.set_parent(remote_branch.base)
2469
finally:
2470
local_branch.unlock()
1842
2471
return status_code
1843
2472
1844
2473
1864
2493
1865
2494
class cmd_testament(Command):
1866
2495
"""Show testament (signing-form) of a revision."""
1867
takes_options = ['revision', 'long']
2496
takes_options = ['revision',
2497
Option('long', help='Produce long-format testament'),
2498
Option('strict', help='Produce a strict-format'
2499
' testament')]
1868
2500
takes_args = ['branch?']
1869
2501
@display_command
1870
def run(self, branch=u'.', revision=None, long=False):
1871
from bzrlib.testament import Testament
2502
def run(self, branch=u'.', revision=None, long=False, strict=False):
2503
from bzrlib.testament import Testament, StrictTestament
2504
if strict is True:
2505
testament_class = StrictTestament
2506
else:
2507
testament_class = Testament
1872
2508
b = WorkingTree.open_containing(branch)[0].branch
1873
2509
b.lock_read()
1874
2510
try:
1876
2512
rev_id = b.last_revision()
1877
2513
else:
1878
2514
rev_id = revision[0].in_history(b).rev_id
1879
t = Testament.from_revision(b, rev_id)
2515
t = testament_class.from_revision(b.repository, rev_id)
1880
2516
if long:
1881
2517
sys.stdout.writelines(t.as_text_lines())
1882
2518
else:
1895
2531
shown only at the top, unless the --all option is given.
1896
2532
"""
1897
2533
# TODO: annotate directories; showing when each file was last changed
1898
# TODO: annotate a previous version of a file
1899
2534
# TODO: if the working copy is modified, show annotations on that
1900
2535
# with new uncommitted lines marked
1901
aliases = ['blame', 'praise']
2536
aliases = ['ann', 'blame', 'praise']
1902
2537
takes_args = ['filename']
1903
2538
takes_options = [Option('all', help='show annotations on all lines'),
1904
2539
Option('long', help='show date in annotations'),
2540
'revision'
1905
2541
]
1906
2542
1907
2543
@display_command
1908
def run(self, filename, all=False, long=False):
2544
def run(self, filename, all=False, long=False, revision=None):
1909
2545
from bzrlib.annotate import annotate_file
1910
2546
tree, relpath = WorkingTree.open_containing(filename)
1911
2547
branch = tree.branch
1912
2548
branch.lock_read()
1913
2549
try:
2550
if revision is None:
2551
revision_id = branch.last_revision()
2552
elif len(revision) != 1:
2553
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2554
else:
2555
revision_id = revision[0].in_history(branch).rev_id
1914
2556
file_id = tree.inventory.path2id(relpath)
1915
tree = branch.revision_tree(branch.last_revision())
2557
tree = branch.repository.revision_tree(revision_id)
1916
2558
file_version = tree.inventory[file_id].revision
1917
2559
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1918
2560
finally:
1924
2566
# TODO be able to replace existing ones.
1925
2567
1926
2568
hidden = True # is this right ?
1927
takes_args = ['revision_id?']
2569
takes_args = ['revision_id*']
1928
2570
takes_options = ['revision']
1929
2571
1930
def run(self, revision_id=None, revision=None):
1931
import bzrlib.config as config
2572
def run(self, revision_id_list=None, revision=None):
1932
2573
import bzrlib.gpg as gpg
1933
if revision_id is not None and revision is not None:
2574
if revision_id_list is not None and revision is not None:
1934
2575
raise BzrCommandError('You can only supply one of revision_id or --revision')
1935
if revision_id is None and revision is None:
2576
if revision_id_list is None and revision is None:
1936
2577
raise BzrCommandError('You must supply either --revision or a revision_id')
1937
2578
b = WorkingTree.open_containing(u'.')[0].branch
1938
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1939
if revision_id is not None:
1940
b.sign_revision(revision_id, gpg_strategy)
2579
gpg_strategy = gpg.GPGStrategy(b.get_config())
2580
if revision_id_list is not None:
2581
for revision_id in revision_id_list:
2582
b.repository.sign_revision(revision_id, gpg_strategy)
1941
2583
elif revision is not None:
1942
2584
if len(revision) == 1:
1943
2585
revno, rev_id = revision[0].in_history(b)
1944
b.sign_revision(rev_id, gpg_strategy)
2586
b.repository.sign_revision(rev_id, gpg_strategy)
1945
2587
elif len(revision) == 2:
1946
2588
# are they both on rh- if so we can walk between them
1947
2589
# might be nice to have a range helper for arbitrary
1953
2595
if from_revno is None or to_revno is None:
1954
2596
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
1955
2597
for revno in range(from_revno, to_revno + 1):
1956
b.sign_revision(b.get_rev_id(revno), gpg_strategy)
2598
b.repository.sign_revision(b.get_rev_id(revno),
2599
gpg_strategy)
1957
2600
else:
1958
2601
raise BzrCommandError('Please supply either one revision, or a range.')
1959
2602
1960
2603
1961
class cmd_uncommit(bzrlib.commands.Command):
2604
class cmd_bind(Command):
2605
"""Bind the current branch to a master branch.
2606
2607
After binding, commits must succeed on the master branch
2608
before they are executed on the local one.
2609
"""
2610
2611
takes_args = ['location']
2612
takes_options = []
2613
2614
def run(self, location=None):
2615
b, relpath = Branch.open_containing(u'.')
2616
b_other = Branch.open(location)
2617
try:
2618
b.bind(b_other)
2619
except DivergedBranches:
2620
raise BzrCommandError('These branches have diverged.'
2621
' Try merging, and then bind again.')
2622
2623
2624
class cmd_unbind(Command):
2625
"""Unbind the current branch from its master branch.
2626
2627
After unbinding, the local branch is considered independent.
2628
All subsequent commits will be local.
2629
"""
2630
2631
takes_args = []
2632
takes_options = []
2633
2634
def run(self):
2635
b, relpath = Branch.open_containing(u'.')
2636
if not b.unbind():
2637
raise BzrCommandError('Local branch is not bound')
2638
2639
2640
class cmd_uncommit(Command):
1962
2641
"""Remove the last committed revision.
1963
2642
1964
By supplying the --all flag, it will not only remove the entry
1965
from revision_history, but also remove all of the entries in the
1966
stores.
1967
1968
2643
--verbose will print out what is being removed.
1969
2644
--dry-run will go through all the motions, but not actually
1970
2645
remove anything.
1971
2646
1972
In the future, uncommit will create a changeset, which can then
2647
In the future, uncommit will create a revision bundle, which can then
1973
2648
be re-applied.
1974
2649
"""
1975
takes_options = ['all', 'verbose', 'revision',
2650
2651
# TODO: jam 20060108 Add an option to allow uncommit to remove
2652
# unreferenced information in 'branch-as-repository' branches.
2653
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2654
# information in shared branches as well.
2655
takes_options = ['verbose', 'revision',
1976
2656
Option('dry-run', help='Don\'t actually make changes'),
1977
2657
Option('force', help='Say yes to all questions.')]
1978
2658
takes_args = ['location?']
1979
2659
aliases = []
1980
2660
1981
def run(self, location=None, all=False,
2661
def run(self, location=None,
1982
2662
dry_run=False, verbose=False,
1983
2663
revision=None, force=False):
1984
from bzrlib.branch import Branch
1985
from bzrlib.log import log_formatter
2664
from bzrlib.log import log_formatter, show_log
1986
2665
import sys
1987
2666
from bzrlib.uncommit import uncommit
1988
2667
1989
2668
if location is None:
1990
2669
location = u'.'
1991
b, relpath = Branch.open_containing(location)
2670
control, relpath = bzrdir.BzrDir.open_containing(location)
2671
try:
2672
tree = control.open_workingtree()
2673
b = tree.branch
2674
except (errors.NoWorkingTree, errors.NotLocalUrl):
2675
tree = None
2676
b = control.open_branch()
1992
2677
2678
rev_id = None
1993
2679
if revision is None:
1994
2680
revno = b.revno()
1995
rev_id = b.last_revision()
1996
2681
else:
1997
revno, rev_id = revision[0].in_history(b)
2682
# 'bzr uncommit -r 10' actually means uncommit
2683
# so that the final tree is at revno 10.
2684
# but bzrlib.uncommit.uncommit() actually uncommits
2685
# the revisions that are supplied.
2686
# So we need to offset it by one
2687
revno = revision[0].in_history(b).revno+1
2688
2689
if revno <= b.revno():
2690
rev_id = b.get_rev_id(revno)
1998
2691
if rev_id is None:
1999
print 'No revisions to uncommit.'
2000
2001
for r in range(revno, b.revno()+1):
2002
rev_id = b.get_rev_id(r)
2003
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2004
lf.show(r, b.get_revision(rev_id), None)
2692
self.outf.write('No revisions to uncommit.\n')
2693
return 1
2694
2695
lf = log_formatter('short',
2696
to_file=self.outf,
2697
show_timezone='original')
2698
2699
show_log(b,
2700
lf,
2701
verbose=False,
2702
direction='forward',
2703
start_revision=revno,
2704
end_revision=b.revno())
2005
2705
2006
2706
if dry_run:
2007
2707
print 'Dry-run, pretending to remove the above revisions.'
2015
2715
print 'Canceled'
2016
2716
return 0
2017
2717
2018
uncommit(b, remove_files=all,
2019
dry_run=dry_run, verbose=verbose,
2718
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2020
2719
revno=revno)
2021
2720
2022
2721
2722
class cmd_break_lock(Command):
2723
"""Break a dead lock on a repository, branch or working directory.
2724
2725
CAUTION: Locks should only be broken when you are sure that the process
2726
holding the lock has been stopped.
2727
2728
You can get information on what locks are open via the 'bzr info' command.
2729
2730
example:
2731
bzr break-lock
2732
"""
2733
takes_args = ['location?']
2734
2735
def run(self, location=None, show=False):
2736
if location is None:
2737
location = u'.'
2738
control, relpath = bzrdir.BzrDir.open_containing(location)
2739
try:
2740
control.break_lock()
2741
except NotImplementedError:
2742
pass
2743
2744
2745
2746
# command-line interpretation helper for merge-related commands
2747
def merge(other_revision, base_revision,
2748
check_clean=True, ignore_zero=False,
2749
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2750
file_list=None, show_base=False, reprocess=False,
2751
pb=DummyProgress()):
2752
"""Merge changes into a tree.
2753
2754
base_revision
2755
list(path, revno) Base for three-way merge.
2756
If [None, None] then a base will be automatically determined.
2757
other_revision
2758
list(path, revno) Other revision for three-way merge.
2759
this_dir
2760
Directory to merge changes into; '.' by default.
2761
check_clean
2762
If true, this_dir must have no uncommitted changes before the
2763
merge begins.
2764
ignore_zero - If true, suppress the "zero conflicts" message when
2765
there are no conflicts; should be set when doing something we expect
2766
to complete perfectly.
2767
file_list - If supplied, merge only changes to selected files.
2768
2769
All available ancestors of other_revision and base_revision are
2770
automatically pulled into the branch.
2771
2772
The revno may be -1 to indicate the last revision on the branch, which is
2773
the typical case.
2774
2775
This function is intended for use from the command line; programmatic
2776
clients might prefer to call merge.merge_inner(), which has less magic
2777
behavior.
2778
"""
2779
from bzrlib.merge import Merger
2780
if this_dir is None:
2781
this_dir = u'.'
2782
this_tree = WorkingTree.open_containing(this_dir)[0]
2783
if show_base and not merge_type is Merge3Merger:
2784
raise BzrCommandError("Show-base is not supported for this merge"
2785
" type. %s" % merge_type)
2786
if reprocess and not merge_type.supports_reprocess:
2787
raise BzrCommandError("Conflict reduction is not supported for merge"
2788
" type %s." % merge_type)
2789
if reprocess and show_base:
2790
raise BzrCommandError("Cannot do conflict reduction and show base.")
2791
try:
2792
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2793
merger.pp = ProgressPhase("Merge phase", 5, pb)
2794
merger.pp.next_phase()
2795
merger.check_basis(check_clean)
2796
merger.set_other(other_revision)
2797
merger.pp.next_phase()
2798
merger.set_base(base_revision)
2799
if merger.base_rev_id == merger.other_rev_id:
2800
note('Nothing to do.')
2801
return 0
2802
merger.backup_files = backup_files
2803
merger.merge_type = merge_type
2804
merger.set_interesting_files(file_list)
2805
merger.show_base = show_base
2806
merger.reprocess = reprocess
2807
conflicts = merger.do_merge()
2808
if file_list is None:
2809
merger.set_pending()
2810
finally:
2811
pb.clear()
2812
return conflicts
2813
2814
2023
2815
# these get imported and then picked up by the scan for cmd_*
2024
2816
# TODO: Some more consistent way to split command definitions across files;
2025
2817
# we do need to load at least some information about them to know of
2026
# aliases.
2818
# aliases. ideally we would avoid loading the implementation until the
2819
# details were needed.
2027
2820
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2821
from bzrlib.bundle.commands import cmd_bundle_revisions
2822
from bzrlib.sign_my_commits import cmd_sign_my_commits
2823
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2824
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1