« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1534.4.28
- compare with another revision
- download diff
- download tarball
- view history from revision 1534.4.28
- Committer: Robert Collins
- Date: 2006-01-26 20:52:58 UTC
- mfrom: (1534.1.16 integration)
- mto: (1551.1.1 bzr.merge.branch-formats) (1508.1.18 checkout) (1534.5.2 bzr-dir)
- mto: This revision was merged to the branch mainline in revision 1553.
- Revision ID: robertc@robertcollins.net-20060126205258-fcf323f36c57112b
first cut at merge from integration.
- files added:
- bzrlib/_merge_core.py
- notes
- patches
- files removed:
- bzrlib/benchmarks
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- tools/doc_generate
- files renamed:
- tools/doc_generate/autodoc_man.py => bzr_man.py
- bzrlib/bundle/__init__.py => bzrlib/_changeset.py
- bzrlib/store/versioned/__init__.py => bzrlib/store/weave.py
- bzrlib/tests/blackbox/test_annotate.py => bzrlib/tests/test_annotate.py
- bzrlib/tests/workingtree_implementations/test_basis_inventory.py => bzrlib/tests/test_basis_inventory.py
- bzrlib/tests/repository_implementations/test_fileid_involved.py => bzrlib/tests/test_fileid_involved.py
- bzrlib/tests/branch_implementations/test_parent.py => bzrlib/tests/test_parent.py
- bzrlib/tests/blackbox/test_uncommit.py => bzrlib/tests/test_uncommit.py
- bzrlib/transport/http/__init__.py => bzrlib/transport/http.py
- doc/tutorial.txt => tutorial.txt
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
1
# Copyright (C) 2004, 2005 by Canonical Ltd
2
2
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""builtin bzr commands"""
18
18
19
19
20
import codecs
21
import errno
22
20
import os
23
from shutil import rmtree
24
21
import sys
25
22
26
23
import bzrlib
27
import bzrlib.branch
24
from bzrlib import BZRDIR
25
from bzrlib._merge_core import ApplyMerge3
26
from bzrlib.commands import Command, display_command
28
27
from bzrlib.branch import Branch
29
import bzrlib.bzrdir as bzrdir
30
from bzrlib.bundle.read_bundle import BundleReader
31
from bzrlib.bundle.apply_bundle import merge_bundle
32
from bzrlib.commands import Command, display_command
28
from bzrlib.revision import common_ancestor
33
29
import bzrlib.errors as errors
34
30
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
35
31
NotBranchError, DivergedBranches, NotConflicted,
36
NoSuchFile, NoWorkingTree, FileInWrongBranch,
37
NotVersionedError, NotABundle)
32
NoSuchFile, NoWorkingTree, FileInWrongBranch)
38
33
from bzrlib.log import show_one_log
39
from bzrlib.merge import Merge3Merger
40
34
from bzrlib.option import Option
41
import bzrlib.osutils
42
from bzrlib.progress import DummyProgress, ProgressPhase
43
from bzrlib.revision import common_ancestor
44
35
from bzrlib.revisionspec import RevisionSpec
45
36
import bzrlib.trace
46
37
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
47
38
from bzrlib.transport.local import LocalTransport
48
import bzrlib.ui
49
import bzrlib.urlutils as urlutils
50
39
from bzrlib.workingtree import WorkingTree
51
40
52
41
57
46
raise BzrCommandError("%s is not in the same branch as %s" %
58
47
(e.path, file_list[0]))
59
48
60
61
# XXX: Bad function name; should possibly also be a class method of
62
# WorkingTree rather than a function.
63
49
def internal_tree_files(file_list, default_branch=u'.'):
64
"""Convert command-line paths to a WorkingTree and relative paths.
65
66
This is typically used for command-line processors that take one or
67
more filenames, and infer the workingtree that contains them.
68
69
The filenames given are not required to exist.
70
71
:param file_list: Filenames to convert.
72
73
:param default_branch: Fallback tree path to use if file_list is empty or None.
74
75
:return: workingtree, [relative_paths]
50
"""\
51
Return a branch and list of branch-relative paths.
52
If supplied file_list is empty or None, the branch default will be used,
53
and returned file_list will match the original.
76
54
"""
77
55
if file_list is None or len(file_list) == 0:
78
56
return WorkingTree.open_containing(default_branch)[0], file_list
86
64
return tree, new_list
87
65
88
66
89
def get_format_type(typestring):
90
"""Parse and return a format specifier."""
91
if typestring == "weave":
92
return bzrdir.BzrDirFormat6()
93
if typestring == "default":
94
return bzrdir.BzrDirMetaFormat1()
95
if typestring == "metaweave":
96
format = bzrdir.BzrDirMetaFormat1()
97
format.repository_format = bzrlib.repository.RepositoryFormat7()
98
return format
99
if typestring == "knit":
100
format = bzrdir.BzrDirMetaFormat1()
101
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
102
return format
103
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
104
"metaweave and weave" % typestring
105
raise BzrCommandError(msg)
106
107
108
67
# TODO: Make sure no commands unconditionally use the working directory as a
109
68
# branch. If a filename argument is used, the first of them should be used to
110
69
# specify the branch. (Perhaps this can be factored out into some kind of
156
115
takes_args = ['file*']
157
116
takes_options = ['all', 'show-ids', 'revision']
158
117
aliases = ['st', 'stat']
159
160
encoding_type = 'replace'
161
118
162
119
@display_command
163
120
def run(self, all=False, show_ids=False, file_list=None, revision=None):
164
from bzrlib.status import show_tree_status
165
166
121
tree, file_list = tree_files(file_list)
167
122
168
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
169
specific_files=file_list, revision=revision,
170
to_file=self.outf)
123
from bzrlib.status import show_status
124
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
125
specific_files=file_list, revision=revision)
171
126
172
127
173
128
class cmd_cat_revision(Command):
180
135
hidden = True
181
136
takes_args = ['revision_id?']
182
137
takes_options = ['revision']
183
# cat-revision is more for frontends so should be exact
184
encoding = 'strict'
185
138
186
139
@display_command
187
140
def run(self, revision_id=None, revision=None):
191
144
if revision_id is None and revision is None:
192
145
raise BzrCommandError('You must supply either --revision or a revision_id')
193
146
b = WorkingTree.open_containing(u'.')[0].branch
194
195
# TODO: jam 20060112 should cat-revision always output utf-8?
196
147
if revision_id is not None:
197
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
148
sys.stdout.write(b.repository.get_revision_xml(revision_id))
198
149
elif revision is not None:
199
150
for rev in revision:
200
151
if rev is None:
201
152
raise BzrCommandError('You cannot specify a NULL revision.')
202
153
revno, rev_id = rev.in_history(b)
203
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
154
sys.stdout.write(b.repository.get_revision_xml(rev_id))
204
155
205
156
206
157
class cmd_revno(Command):
207
158
"""Show current revision number.
208
159
209
This is equal to the number of revisions on this branch.
210
"""
211
160
This is equal to the number of revisions on this branch."""
212
161
takes_args = ['location?']
213
214
162
@display_command
215
163
def run(self, location=u'.'):
216
self.outf.write(str(Branch.open_containing(location)[0].revno()))
217
self.outf.write('\n')
164
print Branch.open_containing(location)[0].revno()
218
165
219
166
220
167
class cmd_revision_info(Command):
223
170
hidden = True
224
171
takes_args = ['revision_info*']
225
172
takes_options = ['revision']
226
227
173
@display_command
228
174
def run(self, revision=None, revision_info_list=[]):
229
175
266
212
267
213
Adding a file whose parent directory is not versioned will
268
214
implicitly add the parent, and so on up to the root. This means
269
you should never need to explicitly add a directory, they'll just
215
you should never need to explictly add a directory, they'll just
270
216
get added when you add a file in the directory.
271
217
272
218
--dry-run will show which files would be added, but not actually
274
220
"""
275
221
takes_args = ['file*']
276
222
takes_options = ['no-recurse', 'dry-run', 'verbose']
277
encoding_type = 'replace'
278
223
279
224
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
280
225
import bzrlib.add
281
226
282
action = bzrlib.add.AddAction(to_file=self.outf,
283
should_print=(not is_quiet()))
227
if dry_run:
228
if is_quiet():
229
# This is pointless, but I'd rather not raise an error
230
action = bzrlib.add.add_action_null
231
else:
232
action = bzrlib.add.add_action_print
233
elif is_quiet():
234
action = bzrlib.add.add_action_add
235
else:
236
action = bzrlib.add.add_action_add_and_print
284
237
285
238
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
286
action=action, save=not dry_run)
239
action)
287
240
if len(ignored) > 0:
288
if verbose:
289
for glob in sorted(ignored.keys()):
241
for glob in sorted(ignored.keys()):
242
match_len = len(ignored[glob])
243
if verbose:
290
244
for path in ignored[glob]:
291
self.outf.write("ignored %s matching \"%s\"\n"
292
% (path, glob))
293
else:
294
match_len = 0
295
for glob, paths in ignored.items():
296
match_len += len(paths)
297
self.outf.write("ignored %d file(s).\n" % match_len)
298
self.outf.write("If you wish to add some of these files,"
299
" please add them by name.\n")
245
print "ignored %s matching \"%s\"" % (path, glob)
246
else:
247
print "ignored %d file(s) matching \"%s\"" % (match_len,
248
glob)
249
print "If you wish to add some of these files, please add them"\
250
" by name."
300
251
301
252
302
253
class cmd_mkdir(Command):
304
255
305
256
This is equivalent to creating the directory and then adding it.
306
257
"""
307
308
258
takes_args = ['dir+']
309
encoding_type = 'replace'
310
259
311
260
def run(self, dir_list):
312
261
for d in dir_list:
313
262
os.mkdir(d)
314
263
wt, dd = WorkingTree.open_containing(d)
315
264
wt.add([dd])
316
self.outf.write('added %s\n' % d)
265
print 'added', d
317
266
318
267
319
268
class cmd_relpath(Command):
320
269
"""Show path of a file relative to root"""
321
322
270
takes_args = ['filename']
323
271
hidden = True
324
272
325
273
@display_command
326
274
def run(self, filename):
327
# TODO: jam 20050106 Can relpath return a munged path if
328
# sys.stdout encoding cannot represent it?
329
275
tree, relpath = WorkingTree.open_containing(filename)
330
self.outf.write(relpath)
331
self.outf.write('\n')
276
print relpath
332
277
333
278
334
279
class cmd_inventory(Command):
337
282
It is possible to limit the output to a particular entry
338
283
type using the --kind option. For example; --kind file.
339
284
"""
340
341
285
takes_options = ['revision', 'show-ids', 'kind']
342
286
343
287
@display_command
358
302
if kind and kind != entry.kind:
359
303
continue
360
304
if show_ids:
361
self.outf.write('%-50s %s\n' % (path, entry.file_id))
305
print '%-50s %s' % (path, entry.file_id)
362
306
else:
363
self.outf.write(path)
364
self.outf.write('\n')
307
print path
308
309
310
class cmd_move(Command):
311
"""Move files to a different directory.
312
313
examples:
314
bzr move *.txt doc
315
316
The destination must be a versioned directory in the same branch.
317
"""
318
takes_args = ['source$', 'dest']
319
def run(self, source_list, dest):
320
tree, source_list = tree_files(source_list)
321
# TODO: glob expansion on windows?
322
tree.move(source_list, tree.relpath(dest))
323
324
325
class cmd_rename(Command):
326
"""Change the name of an entry.
327
328
examples:
329
bzr rename frob.c frobber.c
330
bzr rename src/frob.c lib/frob.c
331
332
It is an error if the destination name exists.
333
334
See also the 'move' command, which moves files into a different
335
directory without changing their name.
336
"""
337
# TODO: Some way to rename multiple files without invoking
338
# bzr for each one?"""
339
takes_args = ['from_name', 'to_name']
340
341
def run(self, from_name, to_name):
342
tree, (from_name, to_name) = tree_files((from_name, to_name))
343
tree.rename_one(from_name, to_name)
365
344
366
345
367
346
class cmd_mv(Command):
377
356
378
357
Files cannot be moved between branches.
379
358
"""
380
381
359
takes_args = ['names*']
382
aliases = ['move', 'rename']
383
encoding_type = 'replace'
384
385
360
def run(self, names_list):
386
361
if len(names_list) < 2:
387
362
raise BzrCommandError("missing file argument")
390
365
if os.path.isdir(names_list[-1]):
391
366
# move into existing directory
392
367
for pair in tree.move(rel_names[:-1], rel_names[-1]):
393
self.outf.write("%s => %s\n" % pair)
368
print "%s => %s" % pair
394
369
else:
395
370
if len(names_list) != 2:
396
371
raise BzrCommandError('to mv multiple files the destination '
397
372
'must be a versioned directory')
398
373
tree.rename_one(rel_names[0], rel_names[1])
399
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
374
print "%s => %s" % (rel_names[0], rel_names[1])
400
375
401
376
402
377
class cmd_pull(Command):
403
"""Turn this branch into a mirror of another branch.
378
"""Pull any changes from another branch into the current one.
379
380
If there is no default location set, the first pull will set it. After
381
that, you can omit the location to use the default. To change the
382
default, use --remember.
404
383
405
384
This command only works on branches that have not diverged. Branches are
406
considered diverged if the destination branch's most recent commit is one
407
that has not been merged (directly or indirectly) into the parent.
408
409
If branches have diverged, you can use 'bzr merge' to integrate the changes
410
from one into the other. Once one branch has merged, the other should
411
be able to pull it again.
385
considered diverged if both branches have had commits without first
386
pulling from the other.
412
387
413
388
If branches have diverged, you can use 'bzr merge' to pull the text changes
414
389
from one into the other. Once one branch has merged, the other should
415
390
be able to pull it again.
416
391
417
392
If you want to forget your local changes and just update your branch to
418
match the remote one, use pull --overwrite.
419
420
If there is no default location set, the first pull will set it. After
421
that, you can omit the location to use the default. To change the
422
default, use --remember.
393
match the remote one, use --overwrite.
423
394
"""
424
425
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
395
takes_options = ['remember', 'overwrite', 'verbose']
426
396
takes_args = ['location?']
427
encoding_type = 'replace'
428
397
429
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
430
# FIXME: too much stuff is in the command class
431
try:
432
tree_to = WorkingTree.open_containing(u'.')[0]
433
branch_to = tree_to.branch
434
except NoWorkingTree:
435
tree_to = None
436
branch_to = Branch.open_containing(u'.')[0]
437
stored_loc = branch_to.get_parent()
398
def run(self, location=None, remember=False, overwrite=False, verbose=False):
399
from shutil import rmtree
400
import errno
401
# FIXME: too much stuff is in the command class
402
tree_to = WorkingTree.open_containing(u'.')[0]
403
stored_loc = tree_to.branch.get_parent()
438
404
if location is None:
439
405
if stored_loc is None:
440
406
raise BzrCommandError("No pull location known or specified.")
441
407
else:
442
display_url = urlutils.unescape_for_display(stored_loc,
443
self.outf.encoding)
444
self.outf.write("Using saved location: %s\n" % display_url)
408
print "Using saved location: %s" % stored_loc
445
409
location = stored_loc
446
410
447
branch_from = Branch.open(location)
448
449
if branch_to.get_parent() is None or remember:
450
branch_to.set_parent(branch_from.base)
451
452
if revision is None:
453
rev_id = None
454
elif len(revision) == 1:
455
rev_id = revision[0].in_history(branch_from).rev_id
456
else:
457
raise BzrCommandError('bzr pull --revision takes one value.')
458
459
old_rh = branch_to.revision_history()
460
if tree_to is not None:
461
count = tree_to.pull(branch_from, overwrite, rev_id)
462
else:
463
count = branch_to.pull(branch_from, overwrite, rev_id)
411
br_from = Branch.open(location)
412
br_to = tree_to.branch
413
414
old_rh = br_to.revision_history()
415
count = tree_to.pull(br_from, overwrite)
416
417
if br_to.get_parent() is None or remember:
418
br_to.set_parent(location)
464
419
note('%d revision(s) pulled.' % (count,))
465
420
466
421
if verbose:
467
new_rh = branch_to.revision_history()
422
new_rh = tree_to.branch.revision_history()
468
423
if old_rh != new_rh:
469
424
# Something changed
470
425
from bzrlib.log import show_changed_revisions
471
show_changed_revisions(branch_to, old_rh, new_rh,
472
to_file=self.outf)
426
show_changed_revisions(tree_to.branch, old_rh, new_rh)
473
427
474
428
475
429
class cmd_push(Command):
476
"""Update a mirror of this branch.
477
478
The target branch will not have its working tree populated because this
479
is both expensive, and is not supported on remote file systems.
480
481
Some smart servers or protocols *may* put the working tree in place in
482
the future.
430
"""Push this branch into another branch.
431
432
The remote branch will not have its working tree populated because this
433
is both expensive, and may not be supported on the remote file system.
434
435
Some smart servers or protocols *may* put the working tree in place.
436
437
If there is no default push location set, the first push will set it.
438
After that, you can omit the location to use the default. To change the
439
default, use --remember.
483
440
484
441
This command only works on branches that have not diverged. Branches are
485
considered diverged if the destination branch's most recent commit is one
486
that has not been merged (directly or indirectly) by the source branch.
442
considered diverged if the branch being pushed to is not an older version
443
of this branch.
487
444
488
445
If branches have diverged, you can use 'bzr push --overwrite' to replace
489
the other branch completely, discarding its unmerged changes.
446
the other branch completely.
490
447
491
448
If you want to ensure you have the different changes in the other branch,
492
do a merge (see bzr help merge) from the other branch, and commit that.
493
After that you will be able to do a push without '--overwrite'.
494
495
If there is no default push location set, the first push will set it.
496
After that, you can omit the location to use the default. To change the
497
default, use --remember.
449
do a merge (see bzr help merge) from the other branch, and commit that
450
before doing a 'push --overwrite'.
498
451
"""
499
500
takes_options = ['remember', 'overwrite', 'verbose',
452
takes_options = ['remember', 'overwrite',
501
453
Option('create-prefix',
502
454
help='Create the path leading up to the branch '
503
455
'if it does not already exist')]
504
456
takes_args = ['location?']
505
encoding_type = 'replace'
506
457
507
458
def run(self, location=None, remember=False, overwrite=False,
508
459
create_prefix=False, verbose=False):
509
460
# FIXME: Way too big! Put this into a function called from the
510
461
# command.
462
import errno
463
from shutil import rmtree
511
464
from bzrlib.transport import get_transport
512
465
513
br_from = Branch.open_containing('.')[0]
514
stored_loc = br_from.get_push_location()
466
tree_from = WorkingTree.open_containing(u'.')[0]
467
br_from = tree_from.branch
468
stored_loc = tree_from.branch.get_push_location()
515
469
if location is None:
516
470
if stored_loc is None:
517
471
raise BzrCommandError("No push location known or specified.")
518
472
else:
519
display_url = urlutils.unescape_for_display(stored_loc,
520
self.outf.encoding)
521
self.outf.write("Using saved location: %s" % display_url)
473
print "Using saved location: %s" % stored_loc
522
474
location = stored_loc
523
524
transport = get_transport(location)
525
location_url = transport.base
526
if br_from.get_push_location() is None or remember:
527
br_from.set_push_location(location_url)
528
529
old_rh = []
530
475
try:
531
dir_to = bzrlib.bzrdir.BzrDir.open(location_url)
532
br_to = dir_to.open_branch()
476
br_to = Branch.open(location)
533
477
except NotBranchError:
534
478
# create a branch.
535
transport = transport.clone('..')
479
transport = get_transport(location).clone('..')
536
480
if not create_prefix:
537
481
try:
538
relurl = transport.relpath(location_url)
539
mutter('creating directory %s => %s', location_url, relurl)
540
transport.mkdir(relurl)
482
transport.mkdir(transport.relpath(location))
541
483
except NoSuchFile:
542
484
raise BzrCommandError("Parent directory of %s "
543
485
"does not exist." % location)
544
486
else:
545
487
current = transport.base
546
needed = [(transport, transport.relpath(location_url))]
488
needed = [(transport, transport.relpath(location))]
547
489
while needed:
548
490
try:
549
491
transport, relpath = needed[-1]
554
496
needed.append((new_transport,
555
497
new_transport.relpath(transport.base)))
556
498
if new_transport.base == transport.base:
557
raise BzrCommandError("Could not create "
499
raise BzrCommandError("Could not creeate "
558
500
"path prefix.")
559
dir_to = br_from.bzrdir.clone(location_url,
560
revision_id=br_from.last_revision())
561
br_to = dir_to.open_branch()
562
count = len(br_to.revision_history())
563
else:
564
old_rh = br_to.revision_history()
501
if isinstance(transport, LocalTransport):
502
br_to = WorkingTree.create_standalone(location).branch
503
else:
504
br_to = Branch.create(location)
505
old_rh = br_to.revision_history()
506
try:
565
507
try:
566
try:
567
tree_to = dir_to.open_workingtree()
568
except errors.NotLocalUrl:
569
warning('This transport does not update the working '
570
'tree of: %s' % (br_to.base,))
571
count = br_to.pull(br_from, overwrite)
572
except NoWorkingTree:
573
count = br_to.pull(br_from, overwrite)
574
else:
575
count = tree_to.pull(br_from, overwrite)
576
except DivergedBranches:
577
raise BzrCommandError("These branches have diverged."
578
" Try a merge then push with overwrite.")
508
tree_to = br_to.working_tree()
509
except NoWorkingTree:
510
# TODO: This should be updated for branches which don't have a
511
# working tree, as opposed to ones where we just couldn't
512
# update the tree.
513
warning('Unable to update the working tree of: %s' % (br_to.base,))
514
count = br_to.pull(br_from, overwrite)
515
else:
516
count = tree_to.pull(br_from, overwrite)
517
except DivergedBranches:
518
raise BzrCommandError("These branches have diverged."
519
" Try a merge then push with overwrite.")
520
if br_from.get_push_location() is None or remember:
521
br_from.set_push_location(location)
579
522
note('%d revision(s) pushed.' % (count,))
580
523
581
524
if verbose:
583
526
if old_rh != new_rh:
584
527
# Something changed
585
528
from bzrlib.log import show_changed_revisions
586
show_changed_revisions(br_to, old_rh, new_rh,
587
to_file=self.outf)
529
show_changed_revisions(br_to, old_rh, new_rh)
588
530
589
531
590
532
class cmd_branch(Command):
605
547
aliases = ['get', 'clone']
606
548
607
549
def run(self, from_location, to_location=None, revision=None, basis=None):
608
from bzrlib.transport import get_transport
609
from bzrlib.osutils import rmtree
550
import errno
551
from shutil import rmtree
610
552
if revision is None:
611
553
revision = [None]
612
554
elif len(revision) > 1:
623
565
br_from.lock_read()
624
566
try:
625
567
if basis is not None:
626
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
568
basis_branch = WorkingTree.open_containing(basis)[0].branch
627
569
else:
628
basis_dir = None
570
basis_branch = None
629
571
if len(revision) == 1 and revision[0] is not None:
630
572
revision_id = revision[0].in_history(br_from)[1]
631
573
else:
632
# FIXME - wt.last_revision, fallback to branch, fall back to
633
# None or perhaps NULL_REVISION to mean copy nothing
634
# RBC 20060209
635
revision_id = br_from.last_revision()
574
revision_id = None
636
575
if to_location is None:
637
576
to_location = os.path.basename(from_location.rstrip("/\\"))
638
577
name = None
639
578
else:
640
579
name = os.path.basename(to_location) + '\n'
641
642
to_transport = get_transport(to_location)
643
try:
644
to_transport.mkdir('.')
645
except bzrlib.errors.FileExists:
646
raise BzrCommandError('Target directory "%s" already'
647
' exists.' % to_location)
648
except bzrlib.errors.NoSuchFile:
649
raise BzrCommandError('Parent of "%s" does not exist.' %
650
to_location)
651
try:
652
# preserve whatever source format we have.
653
dir = br_from.bzrdir.sprout(to_transport.base,
654
revision_id, basis_dir)
655
branch = dir.open_branch()
580
try:
581
os.mkdir(to_location)
582
except OSError, e:
583
if e.errno == errno.EEXIST:
584
raise BzrCommandError('Target directory "%s" already'
585
' exists.' % to_location)
586
if e.errno == errno.ENOENT:
587
raise BzrCommandError('Parent of "%s" does not exist.' %
588
to_location)
589
else:
590
raise
591
try:
592
br_from.clone(to_location, revision_id, basis_branch)
656
593
except bzrlib.errors.NoSuchRevision:
657
to_transport.delete_tree('.')
594
rmtree(to_location)
658
595
msg = "The branch %s has no revision %s." % (from_location, revision[0])
659
596
raise BzrCommandError(msg)
660
597
except bzrlib.errors.UnlistableBranch:
661
598
rmtree(to_location)
662
msg = "The branch %s cannot be used as a --basis" % (basis,)
599
msg = "The branch %s cannot be used as a --basis"
663
600
raise BzrCommandError(msg)
601
branch = Branch.open(to_location)
664
602
if name:
665
603
branch.control_files.put_utf8('branch-name', name)
604
666
605
note('Branched %d revision(s).' % branch.revno())
667
606
finally:
668
607
br_from.unlock()
669
608
670
609
671
class cmd_checkout(Command):
672
"""Create a new checkout of an existing branch.
673
674
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
675
the branch found in '.'. This is useful if you have removed the working tree
676
or if it was never created - i.e. if you pushed the branch to its current
677
location using SFTP.
678
679
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
680
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
681
682
To retrieve the branch as of a particular revision, supply the --revision
683
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
684
out of date [so you cannot commit] but it may be useful (i.e. to examine old
685
code.)
686
687
--basis is to speed up checking out from remote branches. When specified, it
688
uses the inventory and file contents from the basis branch in preference to the
689
branch being checked out.
690
"""
691
takes_args = ['branch_location?', 'to_location?']
692
takes_options = ['revision', # , 'basis']
693
Option('lightweight',
694
help="perform a lightweight checkout. Lightweight "
695
"checkouts depend on access to the branch for "
696
"every operation. Normal checkouts can perform "
697
"common operations like diff and status without "
698
"such access, and also support local commits."
699
),
700
]
701
702
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
703
lightweight=False):
704
if revision is None:
705
revision = [None]
706
elif len(revision) > 1:
707
raise BzrCommandError(
708
'bzr checkout --revision takes exactly 1 revision value')
709
if branch_location is None:
710
branch_location = bzrlib.osutils.getcwd()
711
to_location = branch_location
712
source = Branch.open(branch_location)
713
if len(revision) == 1 and revision[0] is not None:
714
revision_id = revision[0].in_history(source)[1]
715
else:
716
revision_id = None
717
if to_location is None:
718
to_location = os.path.basename(branch_location.rstrip("/\\"))
719
# if the source and to_location are the same,
720
# and there is no working tree,
721
# then reconstitute a branch
722
if (bzrlib.osutils.abspath(to_location) ==
723
bzrlib.osutils.abspath(branch_location)):
724
try:
725
source.bzrdir.open_workingtree()
726
except errors.NoWorkingTree:
727
source.bzrdir.create_workingtree()
728
return
729
try:
730
os.mkdir(to_location)
731
except OSError, e:
732
if e.errno == errno.EEXIST:
733
raise BzrCommandError('Target directory "%s" already'
734
' exists.' % to_location)
735
if e.errno == errno.ENOENT:
736
raise BzrCommandError('Parent of "%s" does not exist.' %
737
to_location)
738
else:
739
raise
740
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
741
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
742
try:
743
if lightweight:
744
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
745
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
746
else:
747
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
748
to_location, force_new_tree=False)
749
checkout = checkout_branch.bzrdir
750
checkout_branch.bind(source)
751
if revision_id is not None:
752
rh = checkout_branch.revision_history()
753
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
754
checkout.create_workingtree(revision_id)
755
finally:
756
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
757
758
759
610
class cmd_renames(Command):
760
611
"""Show list of renamed files.
761
612
"""
767
618
@display_command
768
619
def run(self, dir=u'.'):
769
620
tree = WorkingTree.open_containing(dir)[0]
770
old_inv = tree.basis_tree().inventory
621
old_inv = tree.branch.basis_tree().inventory
771
622
new_inv = tree.read_working_inventory()
772
623
773
624
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
774
625
renames.sort()
775
626
for old_name, new_name in renames:
776
self.outf.write("%s => %s\n" % (old_name, new_name))
777
778
779
class cmd_update(Command):
780
"""Update a tree to have the latest code committed to its branch.
781
782
This will perform a merge into the working tree, and may generate
783
conflicts. If you have any local changes, you will still
784
need to commit them after the update for the update to be complete.
785
786
If you want to discard your local changes, you can just do a
787
'bzr revert' instead of 'bzr commit' after the update.
788
"""
789
takes_args = ['dir?']
790
791
def run(self, dir='.'):
792
tree = WorkingTree.open_containing(dir)[0]
793
tree.lock_write()
794
try:
795
if tree.last_revision() == tree.branch.last_revision():
796
# may be up to date, check master too.
797
master = tree.branch.get_master_branch()
798
if master is None or master.last_revision == tree.last_revision():
799
note("Tree is up to date.")
800
return
801
conflicts = tree.update()
802
note('Updated to revision %d.' %
803
(tree.branch.revision_id_to_revno(tree.last_revision()),))
804
if conflicts != 0:
805
return 1
806
else:
807
return 0
808
finally:
809
tree.unlock()
627
print "%s => %s" % (old_name, new_name)
810
628
811
629
812
630
class cmd_info(Command):
813
"""Show information about a working tree, branch or repository.
814
815
This command will show all known locations and formats associated to the
816
tree, branch or repository. Statistical information is included with
817
each report.
818
819
Branches and working trees will also report any missing revisions.
820
"""
821
takes_args = ['location?']
822
takes_options = ['verbose']
823
631
"""Show statistical information about a branch."""
632
takes_args = ['branch?']
633
824
634
@display_command
825
def run(self, location=None, verbose=False):
826
from bzrlib.info import show_bzrdir_info
827
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
828
verbose=verbose)
635
def run(self, branch=None):
636
import info
637
b = WorkingTree.open_containing(branch)[0].branch
638
info.show_info(b)
829
639
830
640
831
641
class cmd_remove(Command):
833
643
834
644
This makes bzr stop tracking changes to a versioned file. It does
835
645
not delete the working copy.
836
837
You can specify one or more files, and/or --new. If you specify --new,
838
only 'added' files will be removed. If you specify both, then new files
839
in the specified directories will be removed. If the directories are
840
also new, they will also be removed.
841
646
"""
842
takes_args = ['file*']
843
takes_options = ['verbose', Option('new', help='remove newly-added files')]
647
takes_args = ['file+']
648
takes_options = ['verbose']
844
649
aliases = ['rm']
845
encoding_type = 'replace'
846
650
847
def run(self, file_list, verbose=False, new=False):
651
def run(self, file_list, verbose=False):
848
652
tree, file_list = tree_files(file_list)
849
if new is False:
850
if file_list is None:
851
raise BzrCommandError('Specify one or more files to remove, or'
852
' use --new.')
853
else:
854
from bzrlib.delta import compare_trees
855
added = [compare_trees(tree.basis_tree(), tree,
856
specific_files=file_list).added]
857
file_list = sorted([f[0] for f in added[0]], reverse=True)
858
if len(file_list) == 0:
859
raise BzrCommandError('No matching files.')
860
tree.remove(file_list, verbose=verbose, to_file=self.outf)
653
tree.remove(file_list, verbose=verbose)
861
654
862
655
863
656
class cmd_file_id(Command):
867
660
same through all revisions where the file exists, even when it is
868
661
moved or renamed.
869
662
"""
870
871
663
hidden = True
872
664
takes_args = ['filename']
873
874
665
@display_command
875
666
def run(self, filename):
876
667
tree, relpath = WorkingTree.open_containing(filename)
878
669
if i == None:
879
670
raise BzrError("%r is not a versioned file" % filename)
880
671
else:
881
self.outf.write(i + '\n')
672
print i
882
673
883
674
884
675
class cmd_file_path(Command):
885
676
"""Print path of file_ids to a file or directory.
886
677
887
678
This prints one line for each directory down to the target,
888
starting at the branch root.
889
"""
890
679
starting at the branch root."""
891
680
hidden = True
892
681
takes_args = ['filename']
893
894
682
@display_command
895
683
def run(self, filename):
896
684
tree, relpath = WorkingTree.open_containing(filename)
899
687
if fid == None:
900
688
raise BzrError("%r is not a versioned file" % filename)
901
689
for fip in inv.get_idpath(fid):
902
self.outf.write(fip + '\n')
903
904
905
class cmd_reconcile(Command):
906
"""Reconcile bzr metadata in a branch.
907
908
This can correct data mismatches that may have been caused by
909
previous ghost operations or bzr upgrades. You should only
910
need to run this command if 'bzr check' or a bzr developer
911
advises you to run it.
912
913
If a second branch is provided, cross-branch reconciliation is
914
also attempted, which will check that data like the tree root
915
id which was not present in very early bzr versions is represented
916
correctly in both branches.
917
918
At the same time it is run it may recompress data resulting in
919
a potential saving in disk space or performance gain.
920
921
The branch *MUST* be on a listable system such as local disk or sftp.
922
"""
923
takes_args = ['branch?']
924
925
def run(self, branch="."):
926
from bzrlib.reconcile import reconcile
927
dir = bzrlib.bzrdir.BzrDir.open(branch)
928
reconcile(dir)
690
print fip
929
691
930
692
931
693
class cmd_revision_history(Command):
932
694
"""Display list of revision ids on this branch."""
933
695
hidden = True
934
935
696
@display_command
936
697
def run(self):
937
698
branch = WorkingTree.open_containing(u'.')[0].branch
938
699
for patchid in branch.revision_history():
939
self.outf.write(patchid)
940
self.outf.write('\n')
700
print patchid
941
701
942
702
943
703
class cmd_ancestry(Command):
944
704
"""List all revisions merged into this branch."""
945
705
hidden = True
946
947
706
@display_command
948
707
def run(self):
949
708
tree = WorkingTree.open_containing(u'.')[0]
950
709
b = tree.branch
951
710
# FIXME. should be tree.last_revision
952
revision_ids = b.repository.get_ancestry(b.last_revision())
953
assert revision_ids[0] == None
954
revision_ids.pop(0)
955
for revision_id in revision_ids:
956
self.outf.write(revision_id + '\n')
711
for revision_id in b.get_ancestry(b.last_revision()):
712
print revision_id
957
713
958
714
959
715
class cmd_init(Command):
962
718
Use this to create an empty branch, or before importing an
963
719
existing project.
964
720
965
If there is a repository in a parent directory of the location, then
966
the history of the branch will be stored in the repository. Otherwise
967
init creates a standalone branch which carries its own history in
968
.bzr.
969
970
If there is already a branch at the location but it has no working tree,
971
the tree can be populated with 'bzr checkout'.
972
973
721
Recipe for importing a tree of files:
974
722
cd ~/project
975
723
bzr init
978
726
bzr commit -m 'imported project'
979
727
"""
980
728
takes_args = ['location?']
981
takes_options = [
982
Option('format',
983
help='Specify a format for this branch. Current'
984
' formats are: default, knit, metaweave and'
985
' weave. Default is knit; metaweave and'
986
' weave are deprecated',
987
type=get_format_type),
988
]
989
def run(self, location=None, format=None):
729
def run(self, location=None):
990
730
from bzrlib.branch import Branch
991
if format is None:
992
format = get_format_type('default')
993
731
if location is None:
994
732
location = u'.'
995
733
else:
1000
738
# locations if the user supplies an extended path
1001
739
if not os.path.exists(location):
1002
740
os.mkdir(location)
1003
try:
1004
existing_bzrdir = bzrdir.BzrDir.open(location)
1005
except NotBranchError:
1006
# really a NotBzrDir error...
1007
bzrdir.BzrDir.create_branch_convenience(location, format=format)
1008
else:
1009
if existing_bzrdir.has_branch():
1010
if existing_bzrdir.has_workingtree():
1011
raise errors.AlreadyBranchError(location)
1012
else:
1013
raise errors.BranchExistsWithoutWorkingTree(location)
1014
else:
1015
existing_bzrdir.create_branch()
1016
existing_bzrdir.create_workingtree()
1017
1018
1019
class cmd_init_repository(Command):
1020
"""Create a shared repository to hold branches.
1021
1022
New branches created under the repository directory will store their revisions
1023
in the repository, not in the branch directory, if the branch format supports
1024
shared storage.
1025
1026
example:
1027
bzr init-repo repo
1028
bzr init repo/trunk
1029
bzr checkout --lightweight repo/trunk trunk-checkout
1030
cd trunk-checkout
1031
(add files here)
1032
"""
1033
takes_args = ["location"]
1034
takes_options = [Option('format',
1035
help='Specify a format for this repository.'
1036
' Current formats are: default, knit,'
1037
' metaweave and weave. Default is knit;'
1038
' metaweave and weave are deprecated',
1039
type=get_format_type),
1040
Option('trees',
1041
help='Allows branches in repository to have'
1042
' a working tree')]
1043
aliases = ["init-repo"]
1044
def run(self, location, format=None, trees=False):
1045
from bzrlib.transport import get_transport
1046
if format is None:
1047
format = get_format_type('default')
1048
transport = get_transport(location)
1049
if not transport.has('.'):
1050
transport.mkdir('')
1051
newdir = format.initialize_on_transport(transport)
1052
repo = newdir.create_repository(shared=True)
1053
repo.set_make_working_trees(trees)
741
WorkingTree.create_standalone(location)
1054
742
1055
743
1056
744
class cmd_diff(Command):
1059
747
If files are listed, only the changes in those files are listed.
1060
748
Otherwise, all changes for the tree are listed.
1061
749
1062
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1063
produces patches suitable for "patch -p1".
1064
1065
750
examples:
1066
751
bzr diff
1067
752
bzr diff -r1
1068
753
bzr diff -r1..2
1069
bzr diff --diff-prefix old/:new/
1070
bzr diff bzr.mine bzr.dev
1071
bzr diff foo.c
1072
754
"""
755
# TODO: Allow diff across branches.
1073
756
# TODO: Option to use external diff command; could be GNU diff, wdiff,
1074
757
# or a graphical diff.
1075
758
1076
759
# TODO: Python difflib is not exactly the same as unidiff; should
1077
760
# either fix it up or prefer to use an external diff.
1078
761
762
# TODO: If a directory is given, diff everything under that.
763
1079
764
# TODO: Selected-file diff is inefficient and doesn't show you
1080
765
# deleted files.
1081
766
1082
767
# TODO: This probably handles non-Unix newlines poorly.
1083
768
1084
769
takes_args = ['file*']
1085
takes_options = ['revision', 'diff-options', 'prefix']
770
takes_options = ['revision', 'diff-options']
1086
771
aliases = ['di', 'dif']
1087
encoding_type = 'exact'
1088
772
1089
773
@display_command
1090
def run(self, revision=None, file_list=None, diff_options=None,
1091
prefix=None):
1092
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1093
1094
if (prefix is None) or (prefix == '0'):
1095
# diff -p0 format
1096
old_label = ''
1097
new_label = ''
1098
elif prefix == '1':
1099
old_label = 'old/'
1100
new_label = 'new/'
1101
else:
1102
if not ':' in prefix:
1103
raise BzrError("--diff-prefix expects two values separated by a colon")
1104
old_label, new_label = prefix.split(":")
1105
774
def run(self, revision=None, file_list=None, diff_options=None):
775
from bzrlib.diff import show_diff
1106
776
try:
1107
tree1, file_list = internal_tree_files(file_list)
1108
tree2 = None
777
tree, file_list = internal_tree_files(file_list)
1109
778
b = None
1110
779
b2 = None
1111
780
except FileInWrongBranch:
1112
781
if len(file_list) != 2:
1113
782
raise BzrCommandError("Files are in different branches")
1114
783
1115
tree1, file1 = WorkingTree.open_containing(file_list[0])
1116
tree2, file2 = WorkingTree.open_containing(file_list[1])
784
b, file1 = Branch.open_containing(file_list[0])
785
b2, file2 = Branch.open_containing(file_list[1])
1117
786
if file1 != "" or file2 != "":
1118
787
# FIXME diff those two files. rbc 20051123
1119
788
raise BzrCommandError("Files are in different branches")
1120
789
file_list = None
1121
790
if revision is not None:
1122
if tree2 is not None:
791
if b2 is not None:
1123
792
raise BzrCommandError("Can't specify -r with two branches")
1124
793
if (len(revision) == 1) or (revision[1].spec is None):
1125
return diff_cmd_helper(tree1, file_list, diff_options,
1126
revision[0],
1127
old_label=old_label, new_label=new_label)
794
return show_diff(tree.branch, revision[0], specific_files=file_list,
795
external_diff_options=diff_options)
1128
796
elif len(revision) == 2:
1129
return diff_cmd_helper(tree1, file_list, diff_options,
1130
revision[0], revision[1],
1131
old_label=old_label, new_label=new_label)
797
return show_diff(tree.branch, revision[0], specific_files=file_list,
798
external_diff_options=diff_options,
799
revision2=revision[1])
1132
800
else:
1133
801
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1134
802
else:
1135
if tree2 is not None:
1136
return show_diff_trees(tree1, tree2, sys.stdout,
1137
specific_files=file_list,
1138
external_diff_options=diff_options,
1139
old_label=old_label, new_label=new_label)
803
if b is not None:
804
return show_diff(b, None, specific_files=file_list,
805
external_diff_options=diff_options, b2=b2)
1140
806
else:
1141
return diff_cmd_helper(tree1, file_list, diff_options,
1142
old_label=old_label, new_label=new_label)
807
return show_diff(tree.branch, None, specific_files=file_list,
808
external_diff_options=diff_options)
1143
809
1144
810
1145
811
class cmd_deleted(Command):
1151
817
# directories with readdir, rather than stating each one. Same
1152
818
# level of effort but possibly much less IO. (Or possibly not,
1153
819
# if the directories are very large...)
1154
takes_options = ['show-ids']
1155
1156
820
@display_command
1157
821
def run(self, show_ids=False):
1158
822
tree = WorkingTree.open_containing(u'.')[0]
1159
old = tree.basis_tree()
823
old = tree.branch.basis_tree()
1160
824
for path, ie in old.inventory.iter_entries():
1161
825
if not tree.has_id(ie.file_id):
1162
self.outf.write(path)
1163
826
if show_ids:
1164
self.outf.write(' ')
1165
self.outf.write(ie.file_id)
1166
self.outf.write('\n')
827
print '%-50s %s' % (path, ie.file_id)
828
else:
829
print path
1167
830
1168
831
1169
832
class cmd_modified(Command):
1174
837
from bzrlib.delta import compare_trees
1175
838
1176
839
tree = WorkingTree.open_containing(u'.')[0]
1177
td = compare_trees(tree.basis_tree(), tree)
840
td = compare_trees(tree.branch.basis_tree(), tree)
1178
841
1179
842
for path, id, kind, text_modified, meta_modified in td.modified:
1180
self.outf.write(path + '\n')
843
print path
844
1181
845
1182
846
1183
847
class cmd_added(Command):
1186
850
@display_command
1187
851
def run(self):
1188
852
wt = WorkingTree.open_containing(u'.')[0]
1189
basis_inv = wt.basis_tree().inventory
853
basis_inv = wt.branch.basis_tree().inventory
1190
854
inv = wt.inventory
1191
855
for file_id in inv:
1192
856
if file_id in basis_inv:
1194
858
path = inv.id2path(file_id)
1195
859
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1196
860
continue
1197
self.outf.write(path + '\n')
1198
861
print path
862
863
1199
864
1200
865
class cmd_root(Command):
1201
866
"""Show the tree root directory.
1207
872
def run(self, filename=None):
1208
873
"""Print the branch root."""
1209
874
tree = WorkingTree.open_containing(filename)[0]
1210
self.outf.write(tree.basedir + '\n')
875
print tree.basedir
1211
876
1212
877
1213
878
class cmd_log(Command):
1214
"""Show log of a branch, file, or directory.
1215
1216
By default show the log of the branch containing the working directory.
879
"""Show log of this branch.
1217
880
1218
881
To request a range of logs, you can use the command -r begin..end
1219
882
-r revision requests a specific revision, -r ..end or -r begin.. are
1220
883
also valid.
1221
1222
examples:
1223
bzr log
1224
bzr log foo.c
1225
bzr log -r -10.. http://server/branch
1226
884
"""
1227
885
1228
886
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1229
887
1230
takes_args = ['location?']
888
takes_args = ['filename?']
1231
889
takes_options = [Option('forward',
1232
890
help='show from oldest to newest'),
1233
'timezone',
1234
Option('verbose',
1235
help='show files changed in each revision'),
891
'timezone', 'verbose',
1236
892
'show-ids', 'revision',
1237
'log-format',
1238
893
'line', 'long',
1239
894
Option('message',
1240
895
help='show revisions whose message matches this regexp',
1241
896
type=str),
1242
897
'short',
1243
898
]
1244
encoding_type = 'replace'
1245
1246
899
@display_command
1247
def run(self, location=None, timezone='original',
900
def run(self, filename=None, timezone='original',
1248
901
verbose=False,
1249
902
show_ids=False,
1250
903
forward=False,
1251
904
revision=None,
1252
log_format=None,
1253
905
message=None,
1254
906
long=False,
1255
907
short=False,
1256
908
line=False):
1257
909
from bzrlib.log import log_formatter, show_log
910
import codecs
1258
911
assert message is None or isinstance(message, basestring), \
1259
912
"invalid message argument %r" % message
1260
913
direction = (forward and 'forward') or 'reverse'
1261
914
1262
# log everything
1263
file_id = None
1264
if location:
1265
# find the file id to log:
1266
1267
dir, fp = bzrdir.BzrDir.open_containing(location)
1268
b = dir.open_branch()
915
if filename:
916
# might be a tree:
917
tree = None
918
try:
919
tree, fp = WorkingTree.open_containing(filename)
920
b = tree.branch
921
if fp != '':
922
inv = tree.read_working_inventory()
923
except NotBranchError:
924
pass
925
if tree is None:
926
b, fp = Branch.open_containing(filename)
927
if fp != '':
928
inv = b.repository.get_inventory(b.last_revision())
1269
929
if fp != '':
1270
try:
1271
# might be a tree:
1272
inv = dir.open_workingtree().inventory
1273
except (errors.NotBranchError, errors.NotLocalUrl):
1274
# either no tree, or is remote.
1275
inv = b.basis_tree().inventory
1276
930
file_id = inv.path2id(fp)
931
else:
932
file_id = None # points to branch root
1277
933
else:
1278
# local dir only
1279
# FIXME ? log the current subdir only RBC 20060203
1280
dir, relpath = bzrdir.BzrDir.open_containing('.')
1281
b = dir.open_branch()
934
tree, relpath = WorkingTree.open_containing(u'.')
935
b = tree.branch
936
file_id = None
1282
937
1283
938
if revision is None:
1284
939
rev1 = None
1286
941
elif len(revision) == 1:
1287
942
rev1 = rev2 = revision[0].in_history(b).revno
1288
943
elif len(revision) == 2:
1289
if revision[0].spec is None:
1290
# missing begin-range means first revision
1291
rev1 = 1
1292
else:
1293
rev1 = revision[0].in_history(b).revno
1294
1295
if revision[1].spec is None:
1296
# missing end-range means last known revision
1297
rev2 = b.revno()
1298
else:
1299
rev2 = revision[1].in_history(b).revno
944
rev1 = revision[0].in_history(b).revno
945
rev2 = revision[1].in_history(b).revno
1300
946
else:
1301
947
raise BzrCommandError('bzr log --revision takes one or two values.')
1302
948
1306
952
if rev1 > rev2:
1307
953
(rev2, rev1) = (rev1, rev2)
1308
954
1309
if (log_format == None):
1310
default = bzrlib.config.BranchConfig(b).log_format()
1311
log_format = get_log_format(long=long, short=short, line=line, default=default)
955
mutter('encoding log as %r', bzrlib.user_encoding)
956
957
# use 'replace' so that we don't abort if trying to write out
958
# in e.g. the default C locale.
959
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
960
961
log_format = get_log_format(long=long, short=short, line=line)
1312
962
lf = log_formatter(log_format,
1313
963
show_ids=show_ids,
1314
to_file=self.outf,
964
to_file=outf,
1315
965
show_timezone=timezone)
1316
966
1317
967
show_log(b,
1323
973
end_revision=rev2,
1324
974
search=message)
1325
975
1326
1327
976
def get_log_format(long=False, short=False, line=False, default='long'):
1328
977
log_format = default
1329
978
if long:
1338
987
class cmd_touching_revisions(Command):
1339
988
"""Return revision-ids which affected a particular file.
1340
989
1341
A more user-friendly interface is "bzr log FILE".
1342
"""
1343
990
A more user-friendly interface is "bzr log FILE"."""
1344
991
hidden = True
1345
992
takes_args = ["filename"]
1346
1347
993
@display_command
1348
994
def run(self, filename):
1349
995
tree, relpath = WorkingTree.open_containing(filename)
1351
997
inv = tree.read_working_inventory()
1352
998
file_id = inv.path2id(relpath)
1353
999
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1354
self.outf.write("%6d %s\n" % (revno, what))
1000
print "%6d %s" % (revno, what)
1355
1001
1356
1002
1357
1003
class cmd_ls(Command):
1390
1036
if revision is not None:
1391
1037
tree = tree.branch.repository.revision_tree(
1392
1038
revision[0].in_history(tree.branch).rev_id)
1393
1394
1039
for fp, fc, kind, fid, entry in tree.list_files():
1395
1040
if fp.startswith(relpath):
1396
1041
fp = fp[len(relpath):]
1400
1045
continue
1401
1046
if verbose:
1402
1047
kindch = entry.kind_character()
1403
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1048
print '%-8s %s%s' % (fc, fp, kindch)
1404
1049
elif null:
1405
self.outf.write(fp + '\0')
1406
self.outf.flush()
1050
sys.stdout.write(fp)
1051
sys.stdout.write('\0')
1052
sys.stdout.flush()
1407
1053
else:
1408
self.outf.write(fp + '\n')
1054
print fp
1409
1055
1410
1056
1411
1057
class cmd_unknowns(Command):
1414
1060
def run(self):
1415
1061
from bzrlib.osutils import quotefn
1416
1062
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1417
self.outf.write(quotefn(f) + '\n')
1063
print quotefn(f)
1418
1064
1419
1065
1420
1066
class cmd_ignore(Command):
1461
1107
igns += '\n'
1462
1108
igns += name_pattern + '\n'
1463
1109
1464
f = AtomicFile(ifn, 'wt')
1465
1110
try:
1111
f = AtomicFile(ifn, 'wt')
1466
1112
f.write(igns.encode('utf-8'))
1467
1113
f.commit()
1468
1114
finally:
1524
1170
1525
1171
Note: export of tree with non-ascii filenames to zip is not supported.
1526
1172
1527
Supported formats Autodetected by extension
1528
----------------- -------------------------
1173
Supported formats Autodetected by extension
1174
----------------- -------------------------
1529
1175
dir -
1530
1176
tar .tar
1531
1177
tbz2 .tar.bz2, .tbz2
1620
1266
Option('strict',
1621
1267
help="refuse to commit if there are unknown "
1622
1268
"files in the working tree."),
1623
Option('local',
1624
help="perform a local only commit in a bound "
1625
"branch. Such commits are not pushed to "
1626
"the master branch until a normal commit "
1627
"is performed."
1628
),
1629
1269
]
1630
1270
aliases = ['ci', 'checkin']
1631
1271
1632
1272
def run(self, message=None, file=None, verbose=True, selected_list=None,
1633
unchanged=False, strict=False, local=False):
1634
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1273
unchanged=False, strict=False):
1635
1274
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1636
1275
StrictCommitFailed)
1637
1276
from bzrlib.msgeditor import edit_commit_message, \
1638
1277
make_commit_message_template
1278
from bzrlib.status import show_status
1639
1279
from tempfile import TemporaryFile
1280
import codecs
1640
1281
1641
1282
# TODO: Need a blackbox test for invoking the external editor; may be
1642
1283
# slightly problematic to run this cross-platform.
1647
1288
# TODO: if the commit *does* happen to fail, then save the commit
1648
1289
# message to a temporary file where it can be recovered
1649
1290
tree, selected_list = tree_files(selected_list)
1650
if selected_list == ['']:
1651
# workaround - commit of root of tree should be exactly the same
1652
# as just default commit in that tree, and succeed even though
1653
# selected-file merge commit is not done yet
1654
selected_list = []
1655
1656
if local and not tree.branch.get_bound_location():
1657
raise errors.LocalRequiresBoundBranch()
1658
1291
if message is None and not file:
1659
1292
template = make_commit_message_template(tree, selected_list)
1660
1293
message = edit_commit_message(template)
1665
1298
raise BzrCommandError("please specify either --message or --file")
1666
1299
1667
1300
if file:
1301
import codecs
1668
1302
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1669
1303
1670
1304
if message == "":
1671
1305
raise BzrCommandError("empty commit message specified")
1672
1673
if verbose:
1674
reporter = ReportCommitToLog()
1675
else:
1676
reporter = NullCommitReporter()
1677
1306
1678
1307
try:
1679
1308
tree.commit(message, specific_files=selected_list,
1680
allow_pointless=unchanged, strict=strict, local=local,
1681
reporter=reporter)
1309
allow_pointless=unchanged, strict=strict)
1682
1310
except PointlessCommit:
1683
1311
# FIXME: This should really happen before the file is read in;
1684
1312
# perhaps prepare the commit; get the message; then actually commit
1690
1318
except StrictCommitFailed:
1691
1319
raise BzrCommandError("Commit refused because there are unknown "
1692
1320
"files in the working tree.")
1693
except errors.BoundBranchOutOfDate, e:
1694
raise BzrCommandError(str(e)
1695
+ ' Either unbind, update, or'
1696
' pass --local to commit.')
1321
note('Committed revision %d.' % (tree.branch.revno(),))
1697
1322
1698
1323
1699
1324
class cmd_check(Command):
1732
1357
1733
1358
if c.needs_write:
1734
1359
c.write()
1360
1735
1361
1736
1362
1737
1363
class cmd_upgrade(Command):
1742
1368
during other operations to upgrade.
1743
1369
"""
1744
1370
takes_args = ['url?']
1745
takes_options = [
1746
Option('format',
1747
help='Upgrade to a specific format. Current formats'
1748
' are: default, knit, metaweave and weave.'
1749
' Default is knit; metaweave and weave are'
1750
' deprecated',
1751
type=get_format_type),
1752
]
1753
1754
1755
def run(self, url='.', format=None):
1371
1372
def run(self, url='.'):
1756
1373
from bzrlib.upgrade import upgrade
1757
if format is None:
1758
format = get_format_type('default')
1759
upgrade(url, format)
1374
upgrade(url)
1760
1375
1761
1376
1762
1377
class cmd_whoami(Command):
1778
1393
1779
1394
1780
1395
class cmd_nick(Command):
1781
"""Print or set the branch nickname.
1782
1396
"""\
1397
Print or set the branch nickname.
1783
1398
If unset, the tree root directory name is used as the nickname
1784
1399
To print the current nickname, execute with no argument.
1785
1400
"""
1806
1421
1807
1422
If arguments are given, they are regular expressions that say
1808
1423
which tests should run.
1809
1810
If the global option '--no-plugins' is given, plugins are not loaded
1811
before running the selftests. This has two effects: features provided or
1812
modified by plugins will not be tested, and tests provided by plugins will
1813
not be run.
1814
1815
examples:
1816
bzr selftest ignore
1817
bzr --no-plugins selftest -v
1818
1424
"""
1819
1425
# TODO: --list should give a list of all available tests
1820
1426
1828
1434
if typestring == "memory":
1829
1435
from bzrlib.transport.memory import MemoryServer
1830
1436
return MemoryServer
1831
if typestring == "fakenfs":
1832
from bzrlib.transport.fakenfs import FakeNFSServer
1833
return FakeNFSServer
1834
1437
msg = "No known transport type %s. Supported types are: sftp\n" %\
1835
1438
(typestring)
1836
1439
raise BzrCommandError(msg)
1837
1440
1838
1441
hidden = True
1839
1442
takes_args = ['testspecs*']
1840
takes_options = ['verbose',
1443
takes_options = ['verbose',
1841
1444
Option('one', help='stop when one test fails'),
1842
1445
Option('keep-output',
1843
1446
help='keep output directories when tests fail'),
1845
1448
help='Use a different transport by default '
1846
1449
'throughout the test suite.',
1847
1450
type=get_transport_type),
1848
Option('benchmark', help='run the bzr bencharks.'),
1849
Option('lsprof-timed',
1850
help='generate lsprof output for benchmarked'
1851
' sections of code.'),
1852
]
1451
]
1853
1452
1854
def run(self, testspecs_list=None, verbose=None, one=False,
1855
keep_output=False, transport=None, benchmark=None,
1856
lsprof_timed=None):
1453
def run(self, testspecs_list=None, verbose=False, one=False,
1454
keep_output=False, transport=None):
1857
1455
import bzrlib.ui
1858
1456
from bzrlib.tests import selftest
1859
import bzrlib.benchmarks as benchmarks
1860
1457
# we don't want progress meters from the tests to go to the
1861
1458
# real output; and we don't want log messages cluttering up
1862
1459
# the real logs.
1863
1460
save_ui = bzrlib.ui.ui_factory
1864
print '%10s: %s' % ('bzr', bzrlib.osutils.realpath(sys.argv[0]))
1865
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1866
print
1867
1461
bzrlib.trace.info('running tests...')
1868
1462
try:
1869
1463
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1871
1465
pattern = '|'.join(testspecs_list)
1872
1466
else:
1873
1467
pattern = ".*"
1874
if benchmark:
1875
test_suite_factory = benchmarks.test_suite
1876
if verbose is None:
1877
verbose = True
1878
else:
1879
test_suite_factory = None
1880
if verbose is None:
1881
verbose = False
1882
1468
result = selftest(verbose=verbose,
1883
1469
pattern=pattern,
1884
1470
stop_on_failure=one,
1885
1471
keep_output=keep_output,
1886
transport=transport,
1887
test_suite_factory=test_suite_factory,
1888
lsprof_timed=lsprof_timed)
1472
transport=transport)
1889
1473
if result:
1890
1474
bzrlib.trace.info('tests passed')
1891
1475
else:
1920
1504
print " nick: %s" % (branch.nick,)
1921
1505
if rh:
1922
1506
print " revid: %s" % (rh[-1],)
1923
print "Using python interpreter:", sys.executable
1924
import site
1925
print "Using python standard library:", os.path.dirname(site.__file__)
1926
print "Using bzrlib:",
1927
if len(bzrlib.__path__) > 1:
1928
# print repr, which is a good enough way of making it clear it's
1929
# more than one element (eg ['/foo/bar', '/foo/bzr'])
1930
print repr(bzrlib.__path__)
1931
else:
1932
print bzrlib.__path__[0]
1933
1934
print
1935
1507
print bzrlib.__copyright__
1936
print "http://bazaar-vcs.org/"
1508
print "http://bazaar-ng.org/"
1937
1509
print
1938
1510
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1939
1511
print "you may use, modify and redistribute it under the terms of the GNU"
1975
1547
last1 = branch1.last_revision()
1976
1548
last2 = branch2.last_revision()
1977
1549
1978
source = MultipleRevisionSources(branch1.repository,
1979
branch2.repository)
1550
source = MultipleRevisionSources(branch1, branch2)
1980
1551
1981
1552
base_rev_id = common_ancestor(last1, last2, source)
1982
1553
2004
1575
will be used as a BASE, and the second one as OTHER. Revision
2005
1576
numbers are always relative to the specified branch.
2006
1577
2007
By default, bzr will try to merge in all new work from the other
1578
By default bzr will try to merge in all new work from the other
2008
1579
branch, automatically determining an appropriate base. If this
2009
1580
fails, you may need to give an explicit base.
2010
1581
2011
Merge will do its best to combine the changes in two branches, but there
2012
are some kinds of problems only a human can fix. When it encounters those,
2013
it will mark a conflict. A conflict means that you need to fix something,
2014
before you should commit.
2015
2016
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2017
2018
If there is no default branch set, the first merge will set it. After
2019
that, you can omit the branch to use the default. To change the
2020
default, use --remember.
2021
2022
1582
Examples:
2023
1583
2024
1584
To merge the latest revision from bzr.dev
2032
1592
2033
1593
merge refuses to run if there are any uncommitted changes, unless
2034
1594
--force is given.
2035
2036
The following merge types are available:
2037
1595
"""
2038
1596
takes_args = ['branch?']
2039
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1597
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
2040
1598
Option('show-base', help="Show base revision text in "
2041
1599
"conflicts")]
2042
1600
2043
def help(self):
2044
from merge import merge_type_help
2045
from inspect import getdoc
2046
return getdoc(self) + '\n' + merge_type_help()
2047
2048
1601
def run(self, branch=None, revision=None, force=False, merge_type=None,
2049
show_base=False, reprocess=False, remember=False):
1602
show_base=False, reprocess=False):
1603
from bzrlib._merge_core import ApplyMerge3
2050
1604
if merge_type is None:
2051
merge_type = Merge3Merger
2052
2053
tree = WorkingTree.open_containing(u'.')[0]
2054
2055
try:
2056
if branch is not None:
2057
reader = BundleReader(file(branch, 'rb'))
2058
else:
2059
reader = None
2060
except IOError, e:
2061
if e.errno not in (errno.ENOENT, errno.EISDIR):
2062
raise
2063
reader = None
2064
except NotABundle:
2065
reader = None
2066
if reader is not None:
2067
conflicts = merge_bundle(reader, tree, not force, merge_type,
2068
reprocess, show_base)
2069
if conflicts == 0:
2070
return 0
2071
else:
2072
return 1
2073
2074
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2075
1605
merge_type = ApplyMerge3
1606
if branch is None:
1607
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1608
if branch is None:
1609
raise BzrCommandError("No merge location known or specified.")
1610
else:
1611
print "Using saved location: %s" % branch
2076
1612
if revision is None or len(revision) < 1:
2077
1613
base = [None, None]
2078
1614
other = [branch, -1]
2079
other_branch, path = Branch.open_containing(branch)
2080
1615
else:
2081
1616
if len(revision) == 1:
2082
1617
base = [None, None]
2083
other_branch, path = Branch.open_containing(branch)
1618
other_branch = Branch.open_containing(branch)[0]
2084
1619
revno = revision[0].in_history(other_branch).revno
2085
1620
other = [branch, revno]
2086
1621
else:
2088
1623
if None in revision:
2089
1624
raise BzrCommandError(
2090
1625
"Merge doesn't permit that revision specifier.")
2091
other_branch, path = Branch.open_containing(branch)
2092
2093
base = [branch, revision[0].in_history(other_branch).revno]
2094
other = [branch, revision[1].in_history(other_branch).revno]
2095
2096
if tree.branch.get_parent() is None or remember:
2097
tree.branch.set_parent(other_branch.base)
2098
2099
if path != "":
2100
interesting_files = [path]
2101
else:
2102
interesting_files = None
2103
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1626
b = Branch.open_containing(branch)[0]
1627
1628
base = [branch, revision[0].in_history(b).revno]
1629
other = [branch, revision[1].in_history(b).revno]
1630
2104
1631
try:
2105
try:
2106
conflict_count = merge(other, base, check_clean=(not force),
2107
merge_type=merge_type,
2108
reprocess=reprocess,
2109
show_base=show_base,
2110
pb=pb, file_list=interesting_files)
2111
finally:
2112
pb.finished()
1632
conflict_count = merge(other, base, check_clean=(not force),
1633
merge_type=merge_type, reprocess=reprocess,
1634
show_base=show_base)
2113
1635
if conflict_count != 0:
2114
1636
return 1
2115
1637
else:
2123
1645
"and (if you want) report this to the bzr developers\n")
2124
1646
log_error(m)
2125
1647
2126
# TODO: move up to common parent; this isn't merge-specific anymore.
2127
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2128
"""Use tree.branch's parent if none was supplied.
2129
2130
Report if the remembered location was used.
2131
"""
2132
if supplied_location is not None:
2133
return supplied_location
2134
stored_location = tree.branch.get_parent()
2135
mutter("%s", stored_location)
2136
if stored_location is None:
2137
raise BzrCommandError("No location specified or remembered")
2138
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2139
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2140
return stored_location
2141
2142
1648
2143
1649
class cmd_remerge(Command):
2144
1650
"""Redo a merge.
2145
2146
Use this if you want to try a different merge technique while resolving
2147
conflicts. Some merge techniques are better than others, and remerge
2148
lets you try different ones on different files.
2149
2150
The options for remerge have the same meaning and defaults as the ones for
2151
merge. The difference is that remerge can (only) be run when there is a
2152
pending merge, and it lets you specify particular files.
2153
2154
Examples:
2155
$ bzr remerge --show-base
2156
Re-do the merge of all conflicted files, and show the base text in
2157
conflict regions, in addition to the usual THIS and OTHER texts.
2158
2159
$ bzr remerge --merge-type weave --reprocess foobar
2160
Re-do the merge of "foobar", using the weave merge algorithm, with
2161
additional processing to reduce the size of conflict regions.
2162
2163
The following merge types are available:"""
1651
"""
2164
1652
takes_args = ['file*']
2165
1653
takes_options = ['merge-type', 'reprocess',
2166
1654
Option('show-base', help="Show base revision text in "
2167
1655
"conflicts")]
2168
1656
2169
def help(self):
2170
from merge import merge_type_help
2171
from inspect import getdoc
2172
return getdoc(self) + '\n' + merge_type_help()
2173
2174
1657
def run(self, file_list=None, merge_type=None, show_base=False,
2175
1658
reprocess=False):
2176
1659
from bzrlib.merge import merge_inner, transform_tree
1660
from bzrlib._merge_core import ApplyMerge3
2177
1661
if merge_type is None:
2178
merge_type = Merge3Merger
1662
merge_type = ApplyMerge3
2179
1663
tree, file_list = tree_files(file_list)
2180
1664
tree.lock_write()
2181
1665
try:
2194
1678
interesting_ids = set()
2195
1679
for filename in file_list:
2196
1680
file_id = tree.path2id(filename)
2197
if file_id is None:
2198
raise NotVersionedError(filename)
2199
1681
interesting_ids.add(file_id)
2200
1682
if tree.kind(file_id) != "directory":
2201
1683
continue
2202
1684
2203
1685
for name, ie in tree.inventory.iter_entries(file_id):
2204
1686
interesting_ids.add(ie.file_id)
2205
transform_tree(tree, tree.basis_tree(), interesting_ids)
1687
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
2206
1688
if file_list is None:
2207
1689
restore_files = list(tree.iter_conflicts())
2208
1690
else:
2212
1694
restore(tree.abspath(filename))
2213
1695
except NotConflicted:
2214
1696
pass
2215
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2216
this_tree=tree,
1697
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2217
1698
interesting_ids = interesting_ids,
2218
1699
other_rev_id=pending_merges[0],
2219
1700
merge_type=merge_type,
2248
1729
tree, file_list = tree_files(file_list)
2249
1730
if revision is None:
2250
1731
# FIXME should be tree.last_revision
2251
rev_id = tree.last_revision()
1732
rev_id = tree.branch.last_revision()
2252
1733
elif len(revision) != 1:
2253
1734
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2254
1735
else:
2255
1736
rev_id = revision[0].in_history(tree.branch).rev_id
2256
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2257
try:
2258
tree.revert(file_list,
2259
tree.branch.repository.revision_tree(rev_id),
2260
not no_backup, pb)
2261
finally:
2262
pb.finished()
1737
tree.revert(file_list, tree.branch.repository.revision_tree(rev_id),
1738
not no_backup)
2263
1739
2264
1740
2265
1741
class cmd_assert_fail(Command):
2273
1749
"""Show help on a command or other topic.
2274
1750
2275
1751
For a list of all available commands, say 'bzr help commands'."""
2276
takes_options = [Option('long', 'show help on all commands')]
1752
takes_options = ['long']
2277
1753
takes_args = ['topic?']
2278
aliases = ['?', '--help', '-?', '-h']
1754
aliases = ['?']
2279
1755
2280
1756
@display_command
2281
1757
def run(self, topic=None, long=False):
2323
1799
'Display changes in the local branch only'),
2324
1800
Option('theirs-only',
2325
1801
'Display changes in the remote branch only'),
2326
'log-format',
2327
1802
'line',
2328
1803
'long',
2329
1804
'short',
2332
1807
]
2333
1808
2334
1809
def run(self, other_branch=None, reverse=False, mine_only=False,
2335
theirs_only=False, log_format=None, long=False, short=False, line=False,
1810
theirs_only=False, long=True, short=False, line=False,
2336
1811
show_ids=False, verbose=False):
2337
1812
from bzrlib.missing import find_unmerged, iter_log_data
2338
1813
from bzrlib.log import log_formatter
2344
1819
raise BzrCommandError("No missing location known or specified.")
2345
1820
print "Using last location: " + local_branch.get_parent()
2346
1821
remote_branch = bzrlib.branch.Branch.open(other_branch)
2347
if remote_branch.base == local_branch.base:
2348
remote_branch = local_branch
2349
local_branch.lock_read()
2350
try:
2351
remote_branch.lock_read()
2352
try:
2353
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2354
if (log_format == None):
2355
default = bzrlib.config.BranchConfig(local_branch).log_format()
2356
log_format = get_log_format(long=long, short=short, line=line, default=default)
2357
lf = log_formatter(log_format, sys.stdout,
2358
show_ids=show_ids,
2359
show_timezone='original')
2360
if reverse is False:
2361
local_extra.reverse()
2362
remote_extra.reverse()
2363
if local_extra and not theirs_only:
2364
print "You have %d extra revision(s):" % len(local_extra)
2365
for data in iter_log_data(local_extra, local_branch.repository,
2366
verbose):
2367
lf.show(*data)
2368
printed_local = True
2369
else:
2370
printed_local = False
2371
if remote_extra and not mine_only:
2372
if printed_local is True:
2373
print "\n\n"
2374
print "You are missing %d revision(s):" % len(remote_extra)
2375
for data in iter_log_data(remote_extra, remote_branch.repository,
2376
verbose):
2377
lf.show(*data)
2378
if not remote_extra and not local_extra:
2379
status_code = 0
2380
print "Branches are up to date."
2381
else:
2382
status_code = 1
2383
finally:
2384
remote_branch.unlock()
2385
finally:
2386
local_branch.unlock()
2387
if not status_code and parent is None and other_branch is not None:
2388
local_branch.lock_write()
2389
try:
2390
# handle race conditions - a parent might be set while we run.
2391
if local_branch.get_parent() is None:
2392
local_branch.set_parent(remote_branch.base)
2393
finally:
2394
local_branch.unlock()
1822
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1823
log_format = get_log_format(long=long, short=short, line=line)
1824
lf = log_formatter(log_format, sys.stdout,
1825
show_ids=show_ids,
1826
show_timezone='original')
1827
if reverse is False:
1828
local_extra.reverse()
1829
remote_extra.reverse()
1830
if local_extra and not theirs_only:
1831
print "You have %d extra revision(s):" % len(local_extra)
1832
for data in iter_log_data(local_extra, local_branch.repository,
1833
verbose):
1834
lf.show(*data)
1835
printed_local = True
1836
else:
1837
printed_local = False
1838
if remote_extra and not mine_only:
1839
if printed_local is True:
1840
print "\n\n"
1841
print "You are missing %d revision(s):" % len(remote_extra)
1842
for data in iter_log_data(remote_extra, remote_branch.repository,
1843
verbose):
1844
lf.show(*data)
1845
if not remote_extra and not local_extra:
1846
status_code = 0
1847
print "Branches are up to date."
1848
else:
1849
status_code = 1
1850
if parent is None and other_branch is not None:
1851
local_branch.set_parent(other_branch)
2395
1852
return status_code
2396
1853
2397
1854
2448
1905
shown only at the top, unless the --all option is given.
2449
1906
"""
2450
1907
# TODO: annotate directories; showing when each file was last changed
1908
# TODO: annotate a previous version of a file
2451
1909
# TODO: if the working copy is modified, show annotations on that
2452
1910
# with new uncommitted lines marked
2453
1911
aliases = ['blame', 'praise']
2454
1912
takes_args = ['filename']
2455
1913
takes_options = [Option('all', help='show annotations on all lines'),
2456
1914
Option('long', help='show date in annotations'),
2457
'revision'
2458
1915
]
2459
1916
2460
1917
@display_command
2461
def run(self, filename, all=False, long=False, revision=None):
1918
def run(self, filename, all=False, long=False):
2462
1919
from bzrlib.annotate import annotate_file
2463
1920
tree, relpath = WorkingTree.open_containing(filename)
2464
1921
branch = tree.branch
2465
1922
branch.lock_read()
2466
1923
try:
2467
if revision is None:
2468
revision_id = branch.last_revision()
2469
elif len(revision) != 1:
2470
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2471
else:
2472
revision_id = revision[0].in_history(branch).rev_id
2473
1924
file_id = tree.inventory.path2id(relpath)
2474
tree = branch.repository.revision_tree(revision_id)
1925
tree = branch.repository.revision_tree(branch.last_revision())
2475
1926
file_version = tree.inventory[file_id].revision
2476
1927
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2477
1928
finally:
2483
1934
# TODO be able to replace existing ones.
2484
1935
2485
1936
hidden = True # is this right ?
2486
takes_args = ['revision_id*']
1937
takes_args = ['revision_id?']
2487
1938
takes_options = ['revision']
2488
1939
2489
def run(self, revision_id_list=None, revision=None):
1940
def run(self, revision_id=None, revision=None):
2490
1941
import bzrlib.config as config
2491
1942
import bzrlib.gpg as gpg
2492
if revision_id_list is not None and revision is not None:
1943
if revision_id is not None and revision is not None:
2493
1944
raise BzrCommandError('You can only supply one of revision_id or --revision')
2494
if revision_id_list is None and revision is None:
1945
if revision_id is None and revision is None:
2495
1946
raise BzrCommandError('You must supply either --revision or a revision_id')
2496
1947
b = WorkingTree.open_containing(u'.')[0].branch
2497
1948
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2498
if revision_id_list is not None:
2499
for revision_id in revision_id_list:
2500
b.repository.sign_revision(revision_id, gpg_strategy)
1949
if revision_id is not None:
1950
b.repository.sign_revision(revision_id, gpg_strategy)
2501
1951
elif revision is not None:
2502
1952
if len(revision) == 1:
2503
1953
revno, rev_id = revision[0].in_history(b)
2519
1969
raise BzrCommandError('Please supply either one revision, or a range.')
2520
1970
2521
1971
2522
class cmd_bind(Command):
2523
"""Bind the current branch to a master branch.
2524
2525
After binding, commits must succeed on the master branch
2526
before they are executed on the local one.
2527
"""
2528
2529
takes_args = ['location']
2530
takes_options = []
2531
2532
def run(self, location=None):
2533
b, relpath = Branch.open_containing(u'.')
2534
b_other = Branch.open(location)
2535
try:
2536
b.bind(b_other)
2537
except DivergedBranches:
2538
raise BzrCommandError('These branches have diverged.'
2539
' Try merging, and then bind again.')
2540
2541
2542
class cmd_unbind(Command):
2543
"""Unbind the current branch from its master branch.
2544
2545
After unbinding, the local branch is considered independent.
2546
All subsequent commits will be local.
2547
"""
2548
2549
takes_args = []
2550
takes_options = []
2551
2552
def run(self):
2553
b, relpath = Branch.open_containing(u'.')
2554
if not b.unbind():
2555
raise BzrCommandError('Local branch is not bound')
2556
2557
2558
1972
class cmd_uncommit(bzrlib.commands.Command):
2559
1973
"""Remove the last committed revision.
2560
1974
1975
By supplying the --all flag, it will not only remove the entry
1976
from revision_history, but also remove all of the entries in the
1977
stores.
1978
2561
1979
--verbose will print out what is being removed.
2562
1980
--dry-run will go through all the motions, but not actually
2563
1981
remove anything.
2564
1982
2565
In the future, uncommit will create a revision bundle, which can then
1983
In the future, uncommit will create a changeset, which can then
2566
1984
be re-applied.
1985
1986
TODO: jam 20060108 Add an option to allow uncommit to remove unreferenced
1987
information in 'branch-as-repostory' branches.
1988
TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
1989
information in shared branches as well.
2567
1990
"""
2568
2569
# TODO: jam 20060108 Add an option to allow uncommit to remove
2570
# unreferenced information in 'branch-as-repository' branches.
2571
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2572
# information in shared branches as well.
2573
1991
takes_options = ['verbose', 'revision',
2574
1992
Option('dry-run', help='Don\'t actually make changes'),
2575
1993
Option('force', help='Say yes to all questions.')]
2586
2004
2587
2005
if location is None:
2588
2006
location = u'.'
2589
control, relpath = bzrdir.BzrDir.open_containing(location)
2590
try:
2591
tree = control.open_workingtree()
2592
b = tree.branch
2593
except (errors.NoWorkingTree, errors.NotLocalUrl):
2594
tree = None
2595
b = control.open_branch()
2007
b, relpath = Branch.open_containing(location)
2596
2008
2597
2009
if revision is None:
2598
2010
revno = b.revno()
2619
2031
print 'Canceled'
2620
2032
return 0
2621
2033
2622
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2034
uncommit(b, dry_run=dry_run, verbose=verbose,
2623
2035
revno=revno)
2624
2036
2625
2037
2626
class cmd_break_lock(Command):
2627
"""Break a dead lock on a repository, branch or working directory.
2628
2629
CAUTION: Locks should only be broken when you are sure that the process
2630
holding the lock has been stopped.
2631
2632
You can get information on what locks are open via the 'bzr info' command.
2633
2634
example:
2635
bzr break-lock
2636
"""
2637
takes_args = ['location?']
2638
2639
def run(self, location=None, show=False):
2640
if location is None:
2641
location = u'.'
2642
control, relpath = bzrdir.BzrDir.open_containing(location)
2643
try:
2644
control.break_lock()
2645
except NotImplementedError:
2646
pass
2647
2648
2649
2650
# command-line interpretation helper for merge-related commands
2651
2038
def merge(other_revision, base_revision,
2652
2039
check_clean=True, ignore_zero=False,
2653
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2654
file_list=None, show_base=False, reprocess=False,
2655
pb=DummyProgress()):
2040
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
2041
file_list=None, show_base=False, reprocess=False):
2656
2042
"""Merge changes into a tree.
2657
2043
2658
2044
base_revision
2680
2066
clients might prefer to call merge.merge_inner(), which has less magic
2681
2067
behavior.
2682
2068
"""
2683
from bzrlib.merge import Merger
2069
from bzrlib.merge import Merger, _MergeConflictHandler
2684
2070
if this_dir is None:
2685
2071
this_dir = u'.'
2686
2072
this_tree = WorkingTree.open_containing(this_dir)[0]
2687
if show_base and not merge_type is Merge3Merger:
2073
if show_base and not merge_type is ApplyMerge3:
2688
2074
raise BzrCommandError("Show-base is not supported for this merge"
2689
2075
" type. %s" % merge_type)
2690
if reprocess and not merge_type.supports_reprocess:
2691
raise BzrCommandError("Conflict reduction is not supported for merge"
2692
" type %s." % merge_type)
2076
if reprocess and not merge_type is ApplyMerge3:
2077
raise BzrCommandError("Reprocess is not supported for this merge"
2078
" type. %s" % merge_type)
2693
2079
if reprocess and show_base:
2694
raise BzrCommandError("Cannot do conflict reduction and show base.")
2695
try:
2696
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2697
merger.pp = ProgressPhase("Merge phase", 5, pb)
2698
merger.pp.next_phase()
2699
merger.check_basis(check_clean)
2700
merger.set_other(other_revision)
2701
merger.pp.next_phase()
2702
merger.set_base(base_revision)
2703
if merger.base_rev_id == merger.other_rev_id:
2704
note('Nothing to do.')
2705
return 0
2706
merger.backup_files = backup_files
2707
merger.merge_type = merge_type
2708
merger.set_interesting_files(file_list)
2709
merger.show_base = show_base
2710
merger.reprocess = reprocess
2711
conflicts = merger.do_merge()
2712
if file_list is None:
2713
merger.set_pending()
2714
finally:
2715
pb.clear()
2080
raise BzrCommandError("Cannot reprocess and show base.")
2081
merger = Merger(this_tree.branch, this_tree=this_tree)
2082
merger.check_basis(check_clean)
2083
merger.set_other(other_revision)
2084
merger.set_base(base_revision)
2085
if merger.base_rev_id == merger.other_rev_id:
2086
note('Nothing to do.')
2087
return 0
2088
merger.backup_files = backup_files
2089
merger.merge_type = merge_type
2090
merger.set_interesting_files(file_list)
2091
merger.show_base = show_base
2092
merger.reprocess = reprocess
2093
merger.conflict_handler = _MergeConflictHandler(merger.this_tree,
2094
merger.base_tree,
2095
merger.other_tree,
2096
ignore_zero=ignore_zero)
2097
conflicts = merger.do_merge()
2098
merger.set_pending()
2716
2099
return conflicts
2717
2100
2718
2101
2719
2102
# these get imported and then picked up by the scan for cmd_*
2720
2103
# TODO: Some more consistent way to split command definitions across files;
2721
2104
# we do need to load at least some information about them to know of
2722
# aliases. ideally we would avoid loading the implementation until the
2723
# details were needed.
2105
# aliases.
2724
2106
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2725
from bzrlib.bundle.commands import cmd_bundle_revisions
2726
from bzrlib.sign_my_commits import cmd_sign_my_commits
2727
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2728
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1