To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1908.3.21
- compare with another revision
- download diff
- download tarball
- view history from revision 1908.3.21
- Committer: Martin Pool
- Date: 2006-10-06 02:04:17 UTC
- mfrom: (1908.10.1 bench_usecases.merge2)
- mto: This revision was merged to the branch mainline in revision 2068.
- Revision ID: mbp@sourcefrog.net-20061006020417-4949ca86f4417a4d
merge additional fix from cfbolz
- files added:
- COPYING.txt
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/plugins/launchpad
- bzrlib/tests/intertree_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/version_info_formats
- tools/win32
- files removed:
- bzrlib/util/configobj/validate.py
- bzrlib/util/urlgrabber
- notes
- files renamed:
- bzrlib/tests/test_annotate.py => bzrlib/tests/blackbox/test_annotate.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
- tutorial.txt => doc/tutorial.txt
- files modified:
- .bzrignore
- setup.py *
added
removed
bzrlib/builtins.py
1
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
17
17
"""builtin bzr commands"""
18
18
19
19
20
import codecs
20
21
import errno
21
22
import os
22
from shutil import rmtree
23
import os.path
23
24
import sys
24
25
25
26
import bzrlib
26
import bzrlib.branch
27
from bzrlib.branch import Branch
28
import bzrlib.bzrdir as 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
29
45
from bzrlib.commands import Command, display_command
30
from bzrlib.revision import common_ancestor
31
import bzrlib.errors as errors
32
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
47
NotBranchError, DivergedBranches, NotConflicted,
34
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
35
NotVersionedError)
36
from bzrlib.log import show_one_log
49
NotVersionedError, NotABundle)
37
50
from bzrlib.merge import Merge3Merger
38
51
from bzrlib.option import Option
39
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
40
54
from bzrlib.revisionspec import RevisionSpec
41
import bzrlib.trace
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
43
56
from bzrlib.transport.local import LocalTransport
44
import bzrlib.ui
57
import bzrlib.tree
45
58
from bzrlib.workingtree import WorkingTree
46
59
47
60
83
96
84
97
def get_format_type(typestring):
85
98
"""Parse and return a format specifier."""
86
if typestring == "metadir":
99
if typestring == "weave":
100
return bzrdir.BzrDirFormat6()
101
if typestring == "default":
87
102
return bzrdir.BzrDirMetaFormat1()
103
if typestring == "metaweave":
104
format = bzrdir.BzrDirMetaFormat1()
105
format.repository_format = repository.RepositoryFormat7()
106
return format
88
107
if typestring == "knit":
89
108
format = bzrdir.BzrDirMetaFormat1()
90
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
91
return format
92
msg = "No known bzr-dir format %s. Supported types are: metadir\n" %\
93
(typestring)
109
format.repository_format = repository.RepositoryFormatKnit1()
110
return format
111
if typestring == "experimental-knit2":
112
format = bzrdir.BzrDirMetaFormat1()
113
format.repository_format = repository.RepositoryFormatKnit2()
114
return format
115
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
116
"metaweave and weave" % typestring
94
117
raise BzrCommandError(msg)
95
118
96
119
121
144
modified
122
145
Text has changed since the previous revision.
123
146
124
unchanged
125
Nothing about this file has changed since the previous revision.
126
Only shown with --all.
127
128
147
unknown
129
148
Not versioned and not matching an ignore pattern.
130
149
143
162
# TODO: --no-recurse, --recurse options
144
163
145
164
takes_args = ['file*']
146
takes_options = ['all', 'show-ids', 'revision']
165
takes_options = ['show-ids', 'revision']
147
166
aliases = ['st', 'stat']
167
168
encoding_type = 'replace'
148
169
149
170
@display_command
150
def run(self, all=False, show_ids=False, file_list=None, revision=None):
151
tree, file_list = tree_files(file_list)
152
171
def run(self, show_ids=False, file_list=None, revision=None):
153
172
from bzrlib.status import show_tree_status
154
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
155
specific_files=file_list, revision=revision)
173
174
tree, file_list = tree_files(file_list)
175
176
show_tree_status(tree, show_ids=show_ids,
177
specific_files=file_list, revision=revision,
178
to_file=self.outf)
156
179
157
180
158
181
class cmd_cat_revision(Command):
165
188
hidden = True
166
189
takes_args = ['revision_id?']
167
190
takes_options = ['revision']
191
# cat-revision is more for frontends so should be exact
192
encoding = 'strict'
168
193
169
194
@display_command
170
195
def run(self, revision_id=None, revision=None):
174
199
if revision_id is None and revision is None:
175
200
raise BzrCommandError('You must supply either --revision or a revision_id')
176
201
b = WorkingTree.open_containing(u'.')[0].branch
202
203
# TODO: jam 20060112 should cat-revision always output utf-8?
177
204
if revision_id is not None:
178
sys.stdout.write(b.repository.get_revision_xml(revision_id))
205
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
179
206
elif revision is not None:
180
207
for rev in revision:
181
208
if rev is None:
182
209
raise BzrCommandError('You cannot specify a NULL revision.')
183
210
revno, rev_id = rev.in_history(b)
184
sys.stdout.write(b.repository.get_revision_xml(rev_id))
211
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
185
212
186
213
187
214
class cmd_revno(Command):
188
215
"""Show current revision number.
189
216
190
This is equal to the number of revisions on this branch."""
217
This is equal to the number of revisions on this branch.
218
"""
219
191
220
takes_args = ['location?']
221
192
222
@display_command
193
223
def run(self, location=u'.'):
194
print Branch.open_containing(location)[0].revno()
224
self.outf.write(str(Branch.open_containing(location)[0].revno()))
225
self.outf.write('\n')
195
226
196
227
197
228
class cmd_revision_info(Command):
200
231
hidden = True
201
232
takes_args = ['revision_info*']
202
233
takes_options = ['revision']
234
203
235
@display_command
204
236
def run(self, revision=None, revision_info_list=[]):
205
237
208
240
revs.extend(revision)
209
241
if revision_info_list is not None:
210
242
for rev in revision_info_list:
211
revs.append(RevisionSpec(rev))
243
revs.append(RevisionSpec.from_string(rev))
212
244
if len(revs) == 0:
213
245
raise BzrCommandError('You must supply a revision identifier')
214
246
242
274
243
275
Adding a file whose parent directory is not versioned will
244
276
implicitly add the parent, and so on up to the root. This means
245
you should never need to explictly add a directory, they'll just
277
you should never need to explicitly add a directory, they'll just
246
278
get added when you add a file in the directory.
247
279
248
280
--dry-run will show which files would be added, but not actually
249
281
add them.
282
283
--file-ids-from will try to use the file ids from the supplied path.
284
It looks up ids trying to find a matching parent directory with the
285
same filename, and then by pure path.
250
286
"""
251
287
takes_args = ['file*']
252
takes_options = ['no-recurse', 'dry-run', 'verbose']
288
takes_options = ['no-recurse', 'dry-run', 'verbose',
289
Option('file-ids-from', type=unicode,
290
help='Lookup file ids from here')]
291
encoding_type = 'replace'
253
292
254
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
293
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
294
file_ids_from=None):
255
295
import bzrlib.add
256
296
257
if dry_run:
258
if is_quiet():
259
# This is pointless, but I'd rather not raise an error
260
action = bzrlib.add.add_action_null
261
else:
262
action = bzrlib.add.add_action_print
263
elif is_quiet():
264
action = bzrlib.add.add_action_add
297
if file_ids_from is not None:
298
try:
299
base_tree, base_path = WorkingTree.open_containing(
300
file_ids_from)
301
except errors.NoWorkingTree:
302
base_branch, base_path = branch.Branch.open_containing(
303
file_ids_from)
304
base_tree = base_branch.basis_tree()
305
306
action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
307
to_file=self.outf, should_print=(not is_quiet()))
265
308
else:
266
action = bzrlib.add.add_action_add_and_print
309
action = bzrlib.add.AddAction(to_file=self.outf,
310
should_print=(not is_quiet()))
267
311
268
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
269
action)
312
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
313
action=action, save=not dry_run)
270
314
if len(ignored) > 0:
271
for glob in sorted(ignored.keys()):
272
match_len = len(ignored[glob])
273
if verbose:
315
if verbose:
316
for glob in sorted(ignored.keys()):
274
317
for path in ignored[glob]:
275
print "ignored %s matching \"%s\"" % (path, glob)
276
else:
277
print "ignored %d file(s) matching \"%s\"" % (match_len,
278
glob)
279
print "If you wish to add some of these files, please add them"\
280
" by name."
318
self.outf.write("ignored %s matching \"%s\"\n"
319
% (path, glob))
320
else:
321
match_len = 0
322
for glob, paths in ignored.items():
323
match_len += len(paths)
324
self.outf.write("ignored %d file(s).\n" % match_len)
325
self.outf.write("If you wish to add some of these files,"
326
" please add them by name.\n")
281
327
282
328
283
329
class cmd_mkdir(Command):
285
331
286
332
This is equivalent to creating the directory and then adding it.
287
333
"""
334
288
335
takes_args = ['dir+']
336
encoding_type = 'replace'
289
337
290
338
def run(self, dir_list):
291
339
for d in dir_list:
292
340
os.mkdir(d)
293
341
wt, dd = WorkingTree.open_containing(d)
294
342
wt.add([dd])
295
print 'added', d
343
self.outf.write('added %s\n' % d)
296
344
297
345
298
346
class cmd_relpath(Command):
299
347
"""Show path of a file relative to root"""
348
300
349
takes_args = ['filename']
301
350
hidden = True
302
351
303
352
@display_command
304
353
def run(self, filename):
354
# TODO: jam 20050106 Can relpath return a munged path if
355
# sys.stdout encoding cannot represent it?
305
356
tree, relpath = WorkingTree.open_containing(filename)
306
print relpath
357
self.outf.write(relpath)
358
self.outf.write('\n')
307
359
308
360
309
361
class cmd_inventory(Command):
310
362
"""Show inventory of the current working copy or a revision.
311
363
312
364
It is possible to limit the output to a particular entry
313
type using the --kind option. For example; --kind file.
365
type using the --kind option. For example: --kind file.
366
367
It is also possible to restrict the list of files to a specific
368
set. For example: bzr inventory --show-ids this/file
314
369
"""
370
315
371
takes_options = ['revision', 'show-ids', 'kind']
316
372
takes_args = ['file*']
373
317
374
@display_command
318
def run(self, revision=None, show_ids=False, kind=None):
375
def run(self, revision=None, show_ids=False, kind=None, file_list=None):
319
376
if kind and kind not in ['file', 'directory', 'symlink']:
320
377
raise BzrCommandError('invalid kind specified')
321
tree = WorkingTree.open_containing(u'.')[0]
322
if revision is None:
323
inv = tree.read_working_inventory()
324
else:
378
379
work_tree, file_list = tree_files(file_list)
380
381
if revision is not None:
325
382
if len(revision) > 1:
326
383
raise BzrCommandError('bzr inventory --revision takes'
327
' exactly one revision identifier')
328
inv = tree.branch.repository.get_revision_inventory(
329
revision[0].in_history(tree.branch).rev_id)
330
331
for path, entry in inv.entries():
384
' exactly one revision identifier')
385
revision_id = revision[0].in_history(work_tree.branch).rev_id
386
tree = work_tree.branch.repository.revision_tree(revision_id)
387
388
# We include work_tree as well as 'tree' here
389
# So that doing '-r 10 path/foo' will lookup whatever file
390
# exists now at 'path/foo' even if it has been renamed, as
391
# well as whatever files existed in revision 10 at path/foo
392
trees = [tree, work_tree]
393
else:
394
tree = work_tree
395
trees = [tree]
396
397
if file_list is not None:
398
file_ids = bzrlib.tree.find_ids_across_trees(file_list, trees,
399
require_versioned=True)
400
# find_ids_across_trees may include some paths that don't
401
# exist in 'tree'.
402
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
403
for file_id in file_ids if file_id in tree)
404
else:
405
entries = tree.inventory.entries()
406
407
for path, entry in entries:
332
408
if kind and kind != entry.kind:
333
409
continue
334
410
if show_ids:
335
print '%-50s %s' % (path, entry.file_id)
411
self.outf.write('%-50s %s\n' % (path, entry.file_id))
336
412
else:
337
print path
413
self.outf.write(path)
414
self.outf.write('\n')
338
415
339
416
340
417
class cmd_mv(Command):
350
427
351
428
Files cannot be moved between branches.
352
429
"""
430
353
431
takes_args = ['names*']
354
432
aliases = ['move', 'rename']
433
encoding_type = 'replace'
355
434
356
435
def run(self, names_list):
436
if names_list is None:
437
names_list = []
438
357
439
if len(names_list) < 2:
358
440
raise BzrCommandError("missing file argument")
359
441
tree, rel_names = tree_files(names_list)
361
443
if os.path.isdir(names_list[-1]):
362
444
# move into existing directory
363
445
for pair in tree.move(rel_names[:-1], rel_names[-1]):
364
print "%s => %s" % pair
446
self.outf.write("%s => %s\n" % pair)
365
447
else:
366
448
if len(names_list) != 2:
367
449
raise BzrCommandError('to mv multiple files the destination '
368
450
'must be a versioned directory')
369
451
tree.rename_one(rel_names[0], rel_names[1])
370
print "%s => %s" % (rel_names[0], rel_names[1])
452
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
371
453
372
454
373
455
class cmd_pull(Command):
381
463
from one into the other. Once one branch has merged, the other should
382
464
be able to pull it again.
383
465
384
If branches have diverged, you can use 'bzr merge' to pull the text changes
385
from one into the other. Once one branch has merged, the other should
386
be able to pull it again.
387
388
466
If you want to forget your local changes and just update your branch to
389
467
match the remote one, use pull --overwrite.
390
468
391
469
If there is no default location set, the first pull will set it. After
392
470
that, you can omit the location to use the default. To change the
393
default, use --remember.
471
default, use --remember. The value will only be saved if the remote
472
location can be accessed.
394
473
"""
474
395
475
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
396
476
takes_args = ['location?']
477
encoding_type = 'replace'
397
478
398
479
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
399
480
# FIXME: too much stuff is in the command class
402
483
branch_to = tree_to.branch
403
484
except NoWorkingTree:
404
485
tree_to = None
405
branch_to = Branch.open_containing(u'.')[0]
486
branch_to = Branch.open_containing(u'.')[0]
487
488
reader = None
489
if location is not None:
490
try:
491
reader = bundle.read_bundle_from_url(location)
492
except NotABundle:
493
pass # Continue on considering this url a Branch
494
406
495
stored_loc = branch_to.get_parent()
407
496
if location is None:
408
497
if stored_loc is None:
409
498
raise BzrCommandError("No pull location known or specified.")
410
499
else:
411
print "Using saved location: %s" % stored_loc
500
display_url = urlutils.unescape_for_display(stored_loc,
501
self.outf.encoding)
502
self.outf.write("Using saved location: %s\n" % display_url)
412
503
location = stored_loc
413
504
414
if branch_to.get_parent() is None or remember:
415
branch_to.set_parent(location)
416
417
branch_from = Branch.open(location)
418
505
506
if reader is not None:
507
install_bundle(branch_to.repository, reader)
508
branch_from = branch_to
509
else:
510
branch_from = Branch.open(location)
511
512
if branch_to.get_parent() is None or remember:
513
branch_to.set_parent(branch_from.base)
514
515
rev_id = None
419
516
if revision is None:
420
rev_id = None
517
if reader is not None:
518
rev_id = reader.target
421
519
elif len(revision) == 1:
422
520
rev_id = revision[0].in_history(branch_from).rev_id
423
521
else:
435
533
if old_rh != new_rh:
436
534
# Something changed
437
535
from bzrlib.log import show_changed_revisions
438
show_changed_revisions(branch_to, old_rh, new_rh)
536
show_changed_revisions(branch_to, old_rh, new_rh,
537
to_file=self.outf)
439
538
440
539
441
540
class cmd_push(Command):
460
559
461
560
If there is no default push location set, the first push will set it.
462
561
After that, you can omit the location to use the default. To change the
463
default, use --remember.
562
default, use --remember. The value will only be saved if the remote
563
location can be accessed.
464
564
"""
465
takes_options = ['remember', 'overwrite',
565
566
takes_options = ['remember', 'overwrite', 'verbose',
466
567
Option('create-prefix',
467
568
help='Create the path leading up to the branch '
468
569
'if it does not already exist')]
469
570
takes_args = ['location?']
571
encoding_type = 'replace'
470
572
471
573
def run(self, location=None, remember=False, overwrite=False,
472
574
create_prefix=False, verbose=False):
473
575
# FIXME: Way too big! Put this into a function called from the
474
576
# command.
475
from bzrlib.transport import get_transport
476
577
477
tree_from = WorkingTree.open_containing(u'.')[0]
478
br_from = tree_from.branch
479
stored_loc = tree_from.branch.get_push_location()
578
br_from = Branch.open_containing('.')[0]
579
stored_loc = br_from.get_push_location()
480
580
if location is None:
481
581
if stored_loc is None:
482
582
raise BzrCommandError("No push location known or specified.")
483
583
else:
484
print "Using saved location: %s" % stored_loc
584
display_url = urlutils.unescape_for_display(stored_loc,
585
self.outf.encoding)
586
self.outf.write("Using saved location: %s\n" % display_url)
485
587
location = stored_loc
486
if br_from.get_push_location() is None or remember:
487
br_from.set_push_location(location)
588
589
to_transport = transport.get_transport(location)
590
location_url = to_transport.base
591
592
old_rh = []
488
593
try:
489
dir_to = bzrlib.bzrdir.BzrDir.open(location)
594
dir_to = bzrdir.BzrDir.open(location_url)
490
595
br_to = dir_to.open_branch()
491
596
except NotBranchError:
492
597
# create a branch.
493
transport = get_transport(location).clone('..')
598
to_transport = to_transport.clone('..')
494
599
if not create_prefix:
495
600
try:
496
transport.mkdir(transport.relpath(location))
601
relurl = to_transport.relpath(location_url)
602
mutter('creating directory %s => %s', location_url, relurl)
603
to_transport.mkdir(relurl)
497
604
except NoSuchFile:
498
605
raise BzrCommandError("Parent directory of %s "
499
606
"does not exist." % location)
500
607
else:
501
current = transport.base
502
needed = [(transport, transport.relpath(location))]
608
current = to_transport.base
609
needed = [(to_transport, to_transport.relpath(location_url))]
503
610
while needed:
504
611
try:
505
transport, relpath = needed[-1]
506
transport.mkdir(relpath)
612
to_transport, relpath = needed[-1]
613
to_transport.mkdir(relpath)
507
614
needed.pop()
508
615
except NoSuchFile:
509
new_transport = transport.clone('..')
616
new_transport = to_transport.clone('..')
510
617
needed.append((new_transport,
511
new_transport.relpath(transport.base)))
512
if new_transport.base == transport.base:
618
new_transport.relpath(to_transport.base)))
619
if new_transport.base == to_transport.base:
513
620
raise BzrCommandError("Could not create "
514
621
"path prefix.")
515
dir_to = br_from.bzrdir.clone(location)
622
dir_to = br_from.bzrdir.clone(location_url,
623
revision_id=br_from.last_revision())
516
624
br_to = dir_to.open_branch()
517
old_rh = br_to.revision_history()
518
try:
625
count = len(br_to.revision_history())
626
# We successfully created the target, remember it
627
if br_from.get_push_location() is None or remember:
628
br_from.set_push_location(br_to.base)
629
else:
630
# We were able to connect to the remote location, so remember it
631
# we don't need to successfully push because of possible divergence.
632
if br_from.get_push_location() is None or remember:
633
br_from.set_push_location(br_to.base)
634
old_rh = br_to.revision_history()
519
635
try:
520
tree_to = dir_to.open_workingtree()
521
except errors.NotLocalUrl:
522
# TODO: This should be updated for branches which don't have a
523
# working tree, as opposed to ones where we just couldn't
524
# update the tree.
525
warning('This transport does not update the working '
526
'tree of: %s' % (br_to.base,))
527
count = br_to.pull(br_from, overwrite)
528
except NoWorkingTree:
529
count = br_to.pull(br_from, overwrite)
530
else:
531
count = tree_to.pull(br_from, overwrite)
532
except DivergedBranches:
533
raise BzrCommandError("These branches have diverged."
534
" Try a merge then push with overwrite.")
636
try:
637
tree_to = dir_to.open_workingtree()
638
except errors.NotLocalUrl:
639
warning('This transport does not update the working '
640
'tree of: %s' % (br_to.base,))
641
count = br_to.pull(br_from, overwrite)
642
except NoWorkingTree:
643
count = br_to.pull(br_from, overwrite)
644
else:
645
count = tree_to.pull(br_from, overwrite)
646
except DivergedBranches:
647
raise BzrCommandError("These branches have diverged."
648
" Try a merge then push with overwrite.")
535
649
note('%d revision(s) pushed.' % (count,))
536
650
537
651
if verbose:
539
653
if old_rh != new_rh:
540
654
# Something changed
541
655
from bzrlib.log import show_changed_revisions
542
show_changed_revisions(br_to, old_rh, new_rh)
656
show_changed_revisions(br_to, old_rh, new_rh,
657
to_file=self.outf)
543
658
544
659
545
660
class cmd_branch(Command):
591
706
name = None
592
707
else:
593
708
name = os.path.basename(to_location) + '\n'
709
710
to_transport = transport.get_transport(to_location)
594
711
try:
595
os.mkdir(to_location)
596
except OSError, e:
597
if e.errno == errno.EEXIST:
598
raise BzrCommandError('Target directory "%s" already'
599
' exists.' % to_location)
600
if e.errno == errno.ENOENT:
601
raise BzrCommandError('Parent of "%s" does not exist.' %
602
to_location)
603
else:
604
raise
712
to_transport.mkdir('.')
713
except errors.FileExists:
714
raise BzrCommandError('Target directory "%s" already'
715
' exists.' % to_location)
716
except errors.NoSuchFile:
717
raise BzrCommandError('Parent of "%s" does not exist.' %
718
to_location)
605
719
try:
606
720
# preserve whatever source format we have.
607
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
721
dir = br_from.bzrdir.sprout(to_transport.base,
722
revision_id, basis_dir)
608
723
branch = dir.open_branch()
609
except bzrlib.errors.NoSuchRevision:
610
rmtree(to_location)
724
except errors.NoSuchRevision:
725
to_transport.delete_tree('.')
611
726
msg = "The branch %s has no revision %s." % (from_location, revision[0])
612
727
raise BzrCommandError(msg)
613
except bzrlib.errors.UnlistableBranch:
614
rmtree(to_location)
728
except errors.UnlistableBranch:
729
osutils.rmtree(to_location)
615
730
msg = "The branch %s cannot be used as a --basis" % (basis,)
616
731
raise BzrCommandError(msg)
617
732
if name:
618
733
branch.control_files.put_utf8('branch-name', name)
619
620
734
note('Branched %d revision(s).' % branch.revno())
621
735
finally:
622
736
br_from.unlock()
640
754
641
755
--basis is to speed up checking out from remote branches. When specified, it
642
756
uses the inventory and file contents from the basis branch in preference to the
643
branch being checked out. [Not implemented yet.]
757
branch being checked out.
644
758
"""
645
759
takes_args = ['branch_location?', 'to_location?']
646
760
takes_options = ['revision', # , 'basis']
652
766
"such access, and also support local commits."
653
767
),
654
768
]
769
aliases = ['co']
655
770
656
771
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
657
772
lightweight=False):
661
776
raise BzrCommandError(
662
777
'bzr checkout --revision takes exactly 1 revision value')
663
778
if branch_location is None:
664
branch_location = bzrlib.osutils.getcwd()
779
branch_location = osutils.getcwd()
665
780
to_location = branch_location
666
781
source = Branch.open(branch_location)
667
782
if len(revision) == 1 and revision[0] is not None:
673
788
# if the source and to_location are the same,
674
789
# and there is no working tree,
675
790
# then reconstitute a branch
676
if (bzrlib.osutils.abspath(to_location) ==
677
bzrlib.osutils.abspath(branch_location)):
791
if (osutils.abspath(to_location) ==
792
osutils.abspath(branch_location)):
678
793
try:
679
794
source.bzrdir.open_workingtree()
680
795
except errors.NoWorkingTree:
691
806
to_location)
692
807
else:
693
808
raise
694
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
695
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
809
old_format = bzrdir.BzrDirFormat.get_default_format()
810
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
696
811
try:
697
if lightweight:
698
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
699
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
700
else:
701
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
702
to_location, force_new_tree=False)
703
checkout = checkout_branch.bzrdir
704
checkout_branch.bind(source)
705
if revision_id is not None:
706
rh = checkout_branch.revision_history()
707
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
708
checkout.create_workingtree(revision_id)
812
source.create_checkout(to_location, revision_id, lightweight)
709
813
finally:
710
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
814
bzrdir.BzrDirFormat.set_default_format(old_format)
711
815
712
816
713
817
class cmd_renames(Command):
720
824
721
825
@display_command
722
826
def run(self, dir=u'.'):
827
from bzrlib.tree import find_renames
723
828
tree = WorkingTree.open_containing(dir)[0]
724
829
old_inv = tree.basis_tree().inventory
725
830
new_inv = tree.read_working_inventory()
726
727
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
831
renames = list(find_renames(old_inv, new_inv))
728
832
renames.sort()
729
833
for old_name, new_name in renames:
730
print "%s => %s" % (old_name, new_name)
834
self.outf.write("%s => %s\n" % (old_name, new_name))
731
835
732
836
733
837
class cmd_update(Command):
741
845
'bzr revert' instead of 'bzr commit' after the update.
742
846
"""
743
847
takes_args = ['dir?']
848
aliases = ['up']
744
849
745
850
def run(self, dir='.'):
746
851
tree = WorkingTree.open_containing(dir)[0]
747
852
tree.lock_write()
748
853
try:
749
if tree.last_revision() == tree.branch.last_revision():
854
existing_pending_merges = tree.get_parent_ids()[1:]
855
last_rev = tree.last_revision()
856
if last_rev == tree.branch.last_revision():
750
857
# may be up to date, check master too.
751
858
master = tree.branch.get_master_branch()
752
if master is None or master.last_revision == tree.last_revision():
753
note("Tree is up to date.")
754
return
859
if master is None or last_rev == master.last_revision():
860
revno = tree.branch.revision_id_to_revno(last_rev)
861
note("Tree is up to date at revision %d." % (revno,))
862
return 0
755
863
conflicts = tree.update()
756
note('Updated to revision %d.' %
757
(tree.branch.revision_id_to_revno(tree.last_revision()),))
864
revno = tree.branch.revision_id_to_revno(tree.last_revision())
865
note('Updated to revision %d.' % (revno,))
866
if tree.get_parent_ids()[1:] != existing_pending_merges:
867
note('Your local commits will now show as pending merges with '
868
"'bzr status', and can be committed with 'bzr commit'.")
758
869
if conflicts != 0:
759
870
return 1
760
871
else:
764
875
765
876
766
877
class cmd_info(Command):
767
"""Show statistical information about a branch."""
768
takes_args = ['branch?']
878
"""Show information about a working tree, branch or repository.
879
880
This command will show all known locations and formats associated to the
881
tree, branch or repository. Statistical information is included with
882
each report.
883
884
Branches and working trees will also report any missing revisions.
885
"""
886
takes_args = ['location?']
769
887
takes_options = ['verbose']
770
888
771
889
@display_command
772
def run(self, branch=None, verbose=False):
773
import bzrlib.info
774
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0],
775
verbose=verbose)
890
def run(self, location=None, verbose=False):
891
from bzrlib.info import show_bzrdir_info
892
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
893
verbose=verbose)
776
894
777
895
778
896
class cmd_remove(Command):
780
898
781
899
This makes bzr stop tracking changes to a versioned file. It does
782
900
not delete the working copy.
901
902
You can specify one or more files, and/or --new. If you specify --new,
903
only 'added' files will be removed. If you specify both, then new files
904
in the specified directories will be removed. If the directories are
905
also new, they will also be removed.
783
906
"""
784
takes_args = ['file+']
785
takes_options = ['verbose']
907
takes_args = ['file*']
908
takes_options = ['verbose', Option('new', help='remove newly-added files')]
786
909
aliases = ['rm']
910
encoding_type = 'replace'
787
911
788
def run(self, file_list, verbose=False):
912
def run(self, file_list, verbose=False, new=False):
789
913
tree, file_list = tree_files(file_list)
790
tree.remove(file_list, verbose=verbose)
914
if new is False:
915
if file_list is None:
916
raise BzrCommandError('Specify one or more files to remove, or'
917
' use --new.')
918
else:
919
added = tree.changes_from(tree.basis_tree(),
920
specific_files=file_list).added
921
file_list = sorted([f[0] for f in added], reverse=True)
922
if len(file_list) == 0:
923
raise BzrCommandError('No matching files.')
924
tree.remove(file_list, verbose=verbose, to_file=self.outf)
791
925
792
926
793
927
class cmd_file_id(Command):
797
931
same through all revisions where the file exists, even when it is
798
932
moved or renamed.
799
933
"""
934
800
935
hidden = True
801
936
takes_args = ['filename']
937
802
938
@display_command
803
939
def run(self, filename):
804
940
tree, relpath = WorkingTree.open_containing(filename)
805
941
i = tree.inventory.path2id(relpath)
806
if i == None:
942
if i is None:
807
943
raise BzrError("%r is not a versioned file" % filename)
808
944
else:
809
print i
945
self.outf.write(i + '\n')
810
946
811
947
812
948
class cmd_file_path(Command):
813
949
"""Print path of file_ids to a file or directory.
814
950
815
951
This prints one line for each directory down to the target,
816
starting at the branch root."""
952
starting at the branch root.
953
"""
954
817
955
hidden = True
818
956
takes_args = ['filename']
957
819
958
@display_command
820
959
def run(self, filename):
821
960
tree, relpath = WorkingTree.open_containing(filename)
822
961
inv = tree.inventory
823
962
fid = inv.path2id(relpath)
824
if fid == None:
963
if fid is None:
825
964
raise BzrError("%r is not a versioned file" % filename)
826
965
for fip in inv.get_idpath(fid):
827
print fip
966
self.outf.write(fip + '\n')
828
967
829
968
830
969
class cmd_reconcile(Command):
849
988
850
989
def run(self, branch="."):
851
990
from bzrlib.reconcile import reconcile
852
dir = bzrlib.bzrdir.BzrDir.open(branch)
991
dir = bzrdir.BzrDir.open(branch)
853
992
reconcile(dir)
854
993
855
994
856
995
class cmd_revision_history(Command):
857
"""Display list of revision ids on this branch."""
996
"""Display the list of revision ids on a branch."""
997
takes_args = ['location?']
998
858
999
hidden = True
1000
859
1001
@display_command
860
def run(self):
861
branch = WorkingTree.open_containing(u'.')[0].branch
862
for patchid in branch.revision_history():
863
print patchid
1002
def run(self, location="."):
1003
branch = Branch.open_containing(location)[0]
1004
for revid in branch.revision_history():
1005
self.outf.write(revid)
1006
self.outf.write('\n')
864
1007
865
1008
866
1009
class cmd_ancestry(Command):
867
1010
"""List all revisions merged into this branch."""
1011
takes_args = ['location?']
1012
868
1013
hidden = True
1014
869
1015
@display_command
870
def run(self):
871
tree = WorkingTree.open_containing(u'.')[0]
872
b = tree.branch
873
# FIXME. should be tree.last_revision
874
for revision_id in b.repository.get_ancestry(b.last_revision()):
875
print revision_id
1016
def run(self, location="."):
1017
try:
1018
wt = WorkingTree.open_containing(location)[0]
1019
except errors.NoWorkingTree:
1020
b = Branch.open(location)
1021
last_revision = b.last_revision()
1022
else:
1023
b = wt.branch
1024
last_revision = wt.last_revision()
1025
1026
revision_ids = b.repository.get_ancestry(last_revision)
1027
assert revision_ids[0] is None
1028
revision_ids.pop(0)
1029
for revision_id in revision_ids:
1030
self.outf.write(revision_id + '\n')
876
1031
877
1032
878
1033
class cmd_init(Command):
881
1036
Use this to create an empty branch, or before importing an
882
1037
existing project.
883
1038
1039
If there is a repository in a parent directory of the location, then
1040
the history of the branch will be stored in the repository. Otherwise
1041
init creates a standalone branch which carries its own history in
1042
.bzr.
1043
1044
If there is already a branch at the location but it has no working tree,
1045
the tree can be populated with 'bzr checkout'.
1046
884
1047
Recipe for importing a tree of files:
885
1048
cd ~/project
886
1049
bzr init
891
1054
takes_args = ['location?']
892
1055
takes_options = [
893
1056
Option('format',
894
help='Create a specific format rather than the'
895
' current default format. Currently this '
896
' option only accepts "metadir"',
1057
help='Specify a format for this branch. Current'
1058
' formats are: default, knit, metaweave and'
1059
' weave. Default is knit; metaweave and'
1060
' weave are deprecated',
897
1061
type=get_format_type),
898
1062
]
899
1063
def run(self, location=None, format=None):
900
from bzrlib.branch import Branch
1064
if format is None:
1065
format = get_format_type('default')
901
1066
if location is None:
902
1067
location = u'.'
903
else:
904
# The path has to exist to initialize a
905
# branch inside of it.
906
# Just using os.mkdir, since I don't
907
# believe that we want to create a bunch of
908
# locations if the user supplies an extended path
909
if not os.path.exists(location):
910
os.mkdir(location)
911
try:
912
existing = bzrdir.BzrDir.open(location)
1068
1069
to_transport = transport.get_transport(location)
1070
1071
# The path has to exist to initialize a
1072
# branch inside of it.
1073
# Just using os.mkdir, since I don't
1074
# believe that we want to create a bunch of
1075
# locations if the user supplies an extended path
1076
# TODO: create-prefix
1077
try:
1078
to_transport.mkdir('.')
1079
except errors.FileExists:
1080
pass
1081
1082
try:
1083
existing_bzrdir = bzrdir.BzrDir.open(location)
913
1084
except NotBranchError:
1085
# really a NotBzrDir error...
914
1086
bzrdir.BzrDir.create_branch_convenience(location, format=format)
915
1087
else:
916
try:
917
existing.open_branch()
918
except NotBranchError:
919
existing.create_branch()
920
existing.create_workingtree()
921
else:
1088
if existing_bzrdir.has_branch():
1089
if (isinstance(to_transport, LocalTransport)
1090
and not existing_bzrdir.has_workingtree()):
1091
raise errors.BranchExistsWithoutWorkingTree(location)
922
1092
raise errors.AlreadyBranchError(location)
1093
else:
1094
existing_bzrdir.create_branch()
1095
existing_bzrdir.create_workingtree()
923
1096
924
1097
925
1098
class cmd_init_repository(Command):
929
1102
in the repository, not in the branch directory, if the branch format supports
930
1103
shared storage.
931
1104
932
example:
1105
example:
933
1106
bzr init-repo repo
934
bzr init --format=metadir repo/trunk
935
cd repo/trunk
1107
bzr init repo/trunk
1108
bzr checkout --lightweight repo/trunk trunk-checkout
1109
cd trunk-checkout
936
1110
(add files here)
937
1111
"""
938
1112
takes_args = ["location"]
939
1113
takes_options = [Option('format',
940
help='Use a specific format rather than the'
941
' current default format. Currently this'
942
' option only accepts "metadir" and "knit"'
943
' WARNING: the knit format is currently unstable'
944
' and only for experimental use.',
1114
help='Specify a format for this repository.'
1115
' Current formats are: default, knit,'
1116
' metaweave and weave. Default is knit;'
1117
' metaweave and weave are deprecated',
945
1118
type=get_format_type),
946
1119
Option('trees',
947
1120
help='Allows branches in repository to have'
948
1121
' a working tree')]
949
1122
aliases = ["init-repo"]
950
1123
def run(self, location, format=None, trees=False):
951
from bzrlib.bzrdir import BzrDirMetaFormat1
952
from bzrlib.transport import get_transport
953
1124
if format is None:
954
format = BzrDirMetaFormat1()
955
transport = get_transport(location)
956
if not transport.has('.'):
957
transport.mkdir('')
958
newdir = format.initialize_on_transport(transport)
1125
format = get_format_type('default')
1126
1127
if location is None:
1128
location = '.'
1129
1130
to_transport = transport.get_transport(location)
1131
try:
1132
to_transport.mkdir('.')
1133
except errors.FileExists:
1134
pass
1135
1136
newdir = format.initialize_on_transport(to_transport)
959
1137
repo = newdir.create_repository(shared=True)
960
1138
repo.set_make_working_trees(trees)
961
1139
962
1140
963
1141
class cmd_diff(Command):
964
"""Show differences in working tree.
1142
"""Show differences in the working tree or between revisions.
965
1143
966
1144
If files are listed, only the changes in those files are listed.
967
1145
Otherwise, all changes for the tree are listed.
968
1146
1147
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1148
produces patches suitable for "patch -p1".
1149
969
1150
examples:
970
1151
bzr diff
1152
Shows the difference in the working tree versus the last commit
971
1153
bzr diff -r1
1154
Difference between the working tree and revision 1
972
1155
bzr diff -r1..2
1156
Difference between revision 2 and revision 1
1157
bzr diff --diff-prefix old/:new/
1158
Same as 'bzr diff' but prefix paths with old/ and new/
1159
bzr diff bzr.mine bzr.dev
1160
Show the differences between the two working trees
1161
bzr diff foo.c
1162
Show just the differences for 'foo.c'
973
1163
"""
974
# TODO: Allow diff across branches.
975
1164
# TODO: Option to use external diff command; could be GNU diff, wdiff,
976
1165
# or a graphical diff.
977
1166
978
1167
# TODO: Python difflib is not exactly the same as unidiff; should
979
1168
# either fix it up or prefer to use an external diff.
980
1169
981
# TODO: If a directory is given, diff everything under that.
982
983
1170
# TODO: Selected-file diff is inefficient and doesn't show you
984
1171
# deleted files.
985
1172
986
1173
# TODO: This probably handles non-Unix newlines poorly.
987
1174
988
1175
takes_args = ['file*']
989
takes_options = ['revision', 'diff-options']
1176
takes_options = ['revision', 'diff-options', 'prefix']
990
1177
aliases = ['di', 'dif']
1178
encoding_type = 'exact'
991
1179
992
1180
@display_command
993
def run(self, revision=None, file_list=None, diff_options=None):
1181
def run(self, revision=None, file_list=None, diff_options=None,
1182
prefix=None):
994
1183
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1184
1185
if (prefix is None) or (prefix == '0'):
1186
# diff -p0 format
1187
old_label = ''
1188
new_label = ''
1189
elif prefix == '1':
1190
old_label = 'old/'
1191
new_label = 'new/'
1192
else:
1193
if not ':' in prefix:
1194
raise BzrError("--diff-prefix expects two values separated by a colon")
1195
old_label, new_label = prefix.split(":")
1196
995
1197
try:
996
1198
tree1, file_list = internal_tree_files(file_list)
997
1199
tree2 = None
1007
1209
# FIXME diff those two files. rbc 20051123
1008
1210
raise BzrCommandError("Files are in different branches")
1009
1211
file_list = None
1212
except NotBranchError:
1213
if (revision is not None and len(revision) == 2
1214
and not revision[0].needs_branch()
1215
and not revision[1].needs_branch()):
1216
# If both revision specs include a branch, we can
1217
# diff them without needing a local working tree
1218
tree1, tree2 = None, None
1219
else:
1220
raise
1010
1221
if revision is not None:
1011
1222
if tree2 is not None:
1012
1223
raise BzrCommandError("Can't specify -r with two branches")
1013
1224
if (len(revision) == 1) or (revision[1].spec is None):
1014
1225
return diff_cmd_helper(tree1, file_list, diff_options,
1015
revision[0])
1226
revision[0],
1227
old_label=old_label, new_label=new_label)
1016
1228
elif len(revision) == 2:
1017
1229
return diff_cmd_helper(tree1, file_list, diff_options,
1018
revision[0], revision[1])
1230
revision[0], revision[1],
1231
old_label=old_label, new_label=new_label)
1019
1232
else:
1020
1233
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
1021
1234
else:
1022
1235
if tree2 is not None:
1023
1236
return show_diff_trees(tree1, tree2, sys.stdout,
1024
1237
specific_files=file_list,
1025
external_diff_options=diff_options)
1238
external_diff_options=diff_options,
1239
old_label=old_label, new_label=new_label)
1026
1240
else:
1027
return diff_cmd_helper(tree1, file_list, diff_options)
1241
return diff_cmd_helper(tree1, file_list, diff_options,
1242
old_label=old_label, new_label=new_label)
1028
1243
1029
1244
1030
1245
class cmd_deleted(Command):
1036
1251
# directories with readdir, rather than stating each one. Same
1037
1252
# level of effort but possibly much less IO. (Or possibly not,
1038
1253
# if the directories are very large...)
1254
takes_options = ['show-ids']
1255
1039
1256
@display_command
1040
1257
def run(self, show_ids=False):
1041
1258
tree = WorkingTree.open_containing(u'.')[0]
1042
1259
old = tree.basis_tree()
1043
1260
for path, ie in old.inventory.iter_entries():
1044
1261
if not tree.has_id(ie.file_id):
1262
self.outf.write(path)
1045
1263
if show_ids:
1046
print '%-50s %s' % (path, ie.file_id)
1047
else:
1048
print path
1264
self.outf.write(' ')
1265
self.outf.write(ie.file_id)
1266
self.outf.write('\n')
1049
1267
1050
1268
1051
1269
class cmd_modified(Command):
1053
1271
hidden = True
1054
1272
@display_command
1055
1273
def run(self):
1056
from bzrlib.delta import compare_trees
1057
1058
1274
tree = WorkingTree.open_containing(u'.')[0]
1059
td = compare_trees(tree.basis_tree(), tree)
1060
1275
td = tree.changes_from(tree.basis_tree())
1061
1276
for path, id, kind, text_modified, meta_modified in td.modified:
1062
print path
1063
1277
self.outf.write(path + '\n')
1064
1278
1065
1279
1066
1280
class cmd_added(Command):
1075
1289
if file_id in basis_inv:
1076
1290
continue
1077
1291
path = inv.id2path(file_id)
1078
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1292
if not os.access(osutils.abspath(path), os.F_OK):
1079
1293
continue
1080
print path
1081
1082
1294
self.outf.write(path + '\n')
1295
1083
1296
1084
1297
class cmd_root(Command):
1085
1298
"""Show the tree root directory.
1091
1304
def run(self, filename=None):
1092
1305
"""Print the branch root."""
1093
1306
tree = WorkingTree.open_containing(filename)[0]
1094
print tree.basedir
1307
self.outf.write(tree.basedir + '\n')
1095
1308
1096
1309
1097
1310
class cmd_log(Command):
1125
1338
type=str),
1126
1339
'short',
1127
1340
]
1341
encoding_type = 'replace'
1342
1128
1343
@display_command
1129
1344
def run(self, location=None, timezone='original',
1130
1345
verbose=False,
1137
1352
short=False,
1138
1353
line=False):
1139
1354
from bzrlib.log import log_formatter, show_log
1140
import codecs
1141
1355
assert message is None or isinstance(message, basestring), \
1142
1356
"invalid message argument %r" % message
1143
1357
direction = (forward and 'forward') or 'reverse'
1160
1374
else:
1161
1375
# local dir only
1162
1376
# FIXME ? log the current subdir only RBC 20060203
1163
dir, relpath = bzrdir.BzrDir.open_containing('.')
1377
if revision is not None \
1378
and len(revision) > 0 and revision[0].get_branch():
1379
location = revision[0].get_branch()
1380
else:
1381
location = '.'
1382
dir, relpath = bzrdir.BzrDir.open_containing(location)
1164
1383
b = dir.open_branch()
1165
1384
1166
1385
if revision is None:
1169
1388
elif len(revision) == 1:
1170
1389
rev1 = rev2 = revision[0].in_history(b).revno
1171
1390
elif len(revision) == 2:
1391
if revision[1].get_branch() != revision[0].get_branch():
1392
# b is taken from revision[0].get_branch(), and
1393
# show_log will use its revision_history. Having
1394
# different branches will lead to weird behaviors.
1395
raise BzrCommandError(
1396
"Log doesn't accept two revisions in different branches.")
1172
1397
if revision[0].spec is None:
1173
1398
# missing begin-range means first revision
1174
1399
rev1 = 1
1189
1414
if rev1 > rev2:
1190
1415
(rev2, rev1) = (rev1, rev2)
1191
1416
1192
mutter('encoding log as %r', bzrlib.user_encoding)
1193
1194
# use 'replace' so that we don't abort if trying to write out
1195
# in e.g. the default C locale.
1196
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
1197
1198
if (log_format == None):
1199
default = bzrlib.config.BranchConfig(b).log_format()
1200
log_format = get_log_format(long=long, short=short, line=line, default=default)
1201
1417
if (log_format is None):
1418
default = b.get_config().log_format()
1419
log_format = get_log_format(long=long, short=short, line=line,
1420
default=default)
1202
1421
lf = log_formatter(log_format,
1203
1422
show_ids=show_ids,
1204
to_file=outf,
1423
to_file=self.outf,
1205
1424
show_timezone=timezone)
1206
1425
1207
1426
show_log(b,
1228
1447
class cmd_touching_revisions(Command):
1229
1448
"""Return revision-ids which affected a particular file.
1230
1449
1231
A more user-friendly interface is "bzr log FILE"."""
1450
A more user-friendly interface is "bzr log FILE".
1451
"""
1452
1232
1453
hidden = True
1233
1454
takes_args = ["filename"]
1455
1234
1456
@display_command
1235
1457
def run(self, filename):
1236
1458
tree, relpath = WorkingTree.open_containing(filename)
1237
1459
b = tree.branch
1238
1460
inv = tree.read_working_inventory()
1239
1461
file_id = inv.path2id(relpath)
1240
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
1241
print "%6d %s" % (revno, what)
1462
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1463
self.outf.write("%6d %s\n" % (revno, what))
1242
1464
1243
1465
1244
1466
class cmd_ls(Command):
1277
1499
if revision is not None:
1278
1500
tree = tree.branch.repository.revision_tree(
1279
1501
revision[0].in_history(tree.branch).rev_id)
1502
1280
1503
for fp, fc, kind, fid, entry in tree.list_files():
1281
1504
if fp.startswith(relpath):
1282
1505
fp = fp[len(relpath):]
1286
1509
continue
1287
1510
if verbose:
1288
1511
kindch = entry.kind_character()
1289
print '%-8s %s%s' % (fc, fp, kindch)
1512
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1290
1513
elif null:
1291
sys.stdout.write(fp)
1292
sys.stdout.write('\0')
1293
sys.stdout.flush()
1514
self.outf.write(fp + '\0')
1515
self.outf.flush()
1294
1516
else:
1295
print fp
1517
self.outf.write(fp + '\n')
1296
1518
1297
1519
1298
1520
class cmd_unknowns(Command):
1299
1521
"""List unknown files."""
1300
1522
@display_command
1301
1523
def run(self):
1302
from bzrlib.osutils import quotefn
1303
1524
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1304
print quotefn(f)
1525
self.outf.write(osutils.quotefn(f) + '\n')
1305
1526
1306
1527
1307
1528
class cmd_ignore(Command):
1323
1544
bzr ignore '*.class'
1324
1545
"""
1325
1546
# TODO: Complain if the filename is absolute
1326
takes_args = ['name_pattern']
1547
takes_args = ['name_pattern?']
1548
takes_options = [
1549
Option('old-default-rules',
1550
help='Out the ignore rules bzr < 0.9 always used.')
1551
]
1327
1552
1328
def run(self, name_pattern):
1553
def run(self, name_pattern=None, old_default_rules=None):
1329
1554
from bzrlib.atomicfile import AtomicFile
1330
import os.path
1331
1555
if old_default_rules is not None:
1556
# dump the rules and exit
1557
for pattern in ignores.OLD_DEFAULTS:
1558
print pattern
1559
return
1560
if name_pattern is None:
1561
raise BzrCommandError("ignore requires a NAME_PATTERN")
1332
1562
tree, relpath = WorkingTree.open_containing(u'.')
1333
1563
ifn = tree.abspath('.bzrignore')
1334
1335
1564
if os.path.exists(ifn):
1336
1565
f = open(ifn, 'rt')
1337
1566
try:
1348
1577
igns += '\n'
1349
1578
igns += name_pattern + '\n'
1350
1579
1580
f = AtomicFile(ifn, 'wt')
1351
1581
try:
1352
f = AtomicFile(ifn, 'wt')
1353
1582
f.write(igns.encode('utf-8'))
1354
1583
f.commit()
1355
1584
finally:
1422
1651
takes_args = ['dest']
1423
1652
takes_options = ['revision', 'format', 'root']
1424
1653
def run(self, dest, revision=None, format=None, root=None):
1425
import os.path
1426
1654
from bzrlib.export import export
1427
1655
tree = WorkingTree.open_containing(u'.')[0]
1428
1656
b = tree.branch
1459
1687
1460
1688
if tree is None:
1461
1689
b, relpath = Branch.open_containing(filename)
1690
if revision is not None and revision[0].get_branch() is not None:
1691
b = Branch.open(revision[0].get_branch())
1462
1692
if revision is None:
1463
1693
revision_id = b.last_revision()
1464
1694
else:
1471
1701
hidden = True
1472
1702
@display_command
1473
1703
def run(self):
1474
print bzrlib.osutils.local_time_offset()
1704
print osutils.local_time_offset()
1475
1705
1476
1706
1477
1707
1524
1754
from bzrlib.msgeditor import edit_commit_message, \
1525
1755
make_commit_message_template
1526
1756
from tempfile import TemporaryFile
1527
import codecs
1528
1757
1529
1758
# TODO: Need a blackbox test for invoking the external editor; may be
1530
1759
# slightly problematic to run this cross-platform.
1535
1764
# TODO: if the commit *does* happen to fail, then save the commit
1536
1765
# message to a temporary file where it can be recovered
1537
1766
tree, selected_list = tree_files(selected_list)
1767
if selected_list == ['']:
1768
# workaround - commit of root of tree should be exactly the same
1769
# as just default commit in that tree, and succeed even though
1770
# selected-file merge commit is not done yet
1771
selected_list = []
1772
1538
1773
if local and not tree.branch.get_bound_location():
1539
1774
raise errors.LocalRequiresBoundBranch()
1540
1775
if message is None and not file:
1547
1782
raise BzrCommandError("please specify either --message or --file")
1548
1783
1549
1784
if file:
1550
import codecs
1551
1785
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1552
1786
1553
1787
if message == "":
1554
raise BzrCommandError("empty commit message specified")
1788
raise BzrCommandError("empty commit message specified")
1555
1789
1556
1790
if verbose:
1557
1791
reporter = ReportCommitToLog()
1565
1799
except PointlessCommit:
1566
1800
# FIXME: This should really happen before the file is read in;
1567
1801
# perhaps prepare the commit; get the message; then actually commit
1568
raise BzrCommandError("no changes to commit",
1569
["use --unchanged to commit anyhow"])
1802
raise BzrCommandError("no changes to commit."
1803
" use --unchanged to commit anyhow")
1570
1804
except ConflictsInTree:
1571
1805
raise BzrCommandError("Conflicts detected in working tree. "
1572
1806
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1574
1808
raise BzrCommandError("Commit refused because there are unknown "
1575
1809
"files in the working tree.")
1576
1810
except errors.BoundBranchOutOfDate, e:
1577
raise BzrCommandError(str(e)
1578
+ ' Either unbind, update, or'
1579
' pass --local to commit.')
1580
1811
raise BzrCommandError(str(e) + "\n"
1812
'To commit to master branch, run update and then commit.\n'
1813
'You can also pass --local to commit to continue working '
1814
'disconnected.')
1581
1815
1582
1816
class cmd_check(Command):
1583
1817
"""Validate consistency of branch history.
1627
1861
takes_args = ['url?']
1628
1862
takes_options = [
1629
1863
Option('format',
1630
help='Upgrade to a specific format rather than the'
1631
' current default format. Currently this'
1632
' option only accepts "metadir" and "knit".'
1633
' WARNING: the knit format is currently'
1634
' unstable and only for experimental use.',
1864
help='Upgrade to a specific format. Current formats'
1865
' are: default, knit, metaweave and weave.'
1866
' Default is knit; metaweave and weave are'
1867
' deprecated',
1635
1868
type=get_format_type),
1636
1869
]
1637
1870
1638
1871
1639
1872
def run(self, url='.', format=None):
1640
1873
from bzrlib.upgrade import upgrade
1874
if format is None:
1875
format = get_format_type('default')
1641
1876
upgrade(url, format)
1642
1877
1643
1878
1644
1879
class cmd_whoami(Command):
1645
"""Show bzr user id."""
1646
takes_options = ['email']
1880
"""Show or set bzr user id.
1881
1882
examples:
1883
bzr whoami --email
1884
bzr whoami 'Frank Chu <fchu@example.com>'
1885
"""
1886
takes_options = [ Option('email',
1887
help='display email address only'),
1888
Option('branch',
1889
help='set identity for the current branch instead of '
1890
'globally'),
1891
]
1892
takes_args = ['name?']
1893
encoding_type = 'replace'
1647
1894
1648
1895
@display_command
1649
def run(self, email=False):
1896
def run(self, email=False, branch=False, name=None):
1897
if name is None:
1898
# use branch if we're inside one; otherwise global config
1899
try:
1900
c = Branch.open_containing('.')[0].get_config()
1901
except NotBranchError:
1902
c = config.GlobalConfig()
1903
if email:
1904
self.outf.write(c.user_email() + '\n')
1905
else:
1906
self.outf.write(c.username() + '\n')
1907
return
1908
1909
# display a warning if an email address isn't included in the given name.
1650
1910
try:
1651
b = WorkingTree.open_containing(u'.')[0].branch
1652
config = bzrlib.config.BranchConfig(b)
1653
except NotBranchError:
1654
config = bzrlib.config.GlobalConfig()
1911
config.extract_email_address(name)
1912
except BzrError, e:
1913
warning('"%s" does not seem to contain an email address. '
1914
'This is allowed, but not recommended.', name)
1655
1915
1656
if email:
1657
print config.user_email()
1916
# use global config unless --branch given
1917
if branch:
1918
c = Branch.open_containing('.')[0].get_config()
1658
1919
else:
1659
print config.username()
1920
c = config.GlobalConfig()
1921
c.set_user_option('email', name)
1660
1922
1661
1923
1662
1924
class cmd_nick(Command):
1727
1989
help='Use a different transport by default '
1728
1990
'throughout the test suite.',
1729
1991
type=get_transport_type),
1730
]
1992
Option('benchmark', help='run the bzr bencharks.'),
1993
Option('lsprof-timed',
1994
help='generate lsprof output for benchmarked'
1995
' sections of code.'),
1996
Option('cache-dir', type=str,
1997
help='a directory to cache intermediate'
1998
' benchmark steps'),
1999
]
1731
2000
1732
def run(self, testspecs_list=None, verbose=False, one=False,
1733
keep_output=False, transport=None):
2001
def run(self, testspecs_list=None, verbose=None, one=False,
2002
keep_output=False, transport=None, benchmark=None,
2003
lsprof_timed=None, cache_dir=None):
1734
2004
import bzrlib.ui
1735
2005
from bzrlib.tests import selftest
2006
import bzrlib.benchmarks as benchmarks
2007
from bzrlib.benchmarks import tree_creator
2008
2009
if cache_dir is not None:
2010
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
1736
2011
# we don't want progress meters from the tests to go to the
1737
2012
# real output; and we don't want log messages cluttering up
1738
2013
# the real logs.
1739
save_ui = bzrlib.ui.ui_factory
1740
bzrlib.trace.info('running tests...')
2014
save_ui = ui.ui_factory
2015
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
2016
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
2017
print
2018
info('running tests...')
1741
2019
try:
1742
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
2020
ui.ui_factory = ui.SilentUIFactory()
1743
2021
if testspecs_list is not None:
1744
2022
pattern = '|'.join(testspecs_list)
1745
2023
else:
1746
2024
pattern = ".*"
1747
result = selftest(verbose=verbose,
1748
pattern=pattern,
1749
stop_on_failure=one,
1750
keep_output=keep_output,
1751
transport=transport)
2025
if benchmark:
2026
test_suite_factory = benchmarks.test_suite
2027
if verbose is None:
2028
verbose = True
2029
# TODO: should possibly lock the history file...
2030
benchfile = open(".perf_history", "at")
2031
else:
2032
test_suite_factory = None
2033
if verbose is None:
2034
verbose = False
2035
benchfile = None
2036
try:
2037
result = selftest(verbose=verbose,
2038
pattern=pattern,
2039
stop_on_failure=one,
2040
keep_output=keep_output,
2041
transport=transport,
2042
test_suite_factory=test_suite_factory,
2043
lsprof_timed=lsprof_timed,
2044
bench_history=benchfile)
2045
finally:
2046
if benchfile is not None:
2047
benchfile.close()
1752
2048
if result:
1753
bzrlib.trace.info('tests passed')
2049
info('tests passed')
1754
2050
else:
1755
bzrlib.trace.info('tests failed')
2051
info('tests failed')
1756
2052
return int(not result)
1757
2053
finally:
1758
bzrlib.ui.ui_factory = save_ui
1759
1760
1761
def _get_bzr_branch():
1762
"""If bzr is run from a branch, return Branch or None"""
1763
import bzrlib.errors
1764
from bzrlib.branch import Branch
1765
from bzrlib.osutils import abspath
1766
from os.path import dirname
1767
1768
try:
1769
branch = Branch.open(dirname(abspath(dirname(__file__))))
1770
return branch
1771
except bzrlib.errors.BzrError:
1772
return None
1773
1774
1775
def show_version():
1776
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1777
# is bzrlib itself in a branch?
1778
branch = _get_bzr_branch()
1779
if branch:
1780
rh = branch.revision_history()
1781
revno = len(rh)
1782
print " bzr checkout, revision %d" % (revno,)
1783
print " nick: %s" % (branch.nick,)
1784
if rh:
1785
print " revid: %s" % (rh[-1],)
1786
print bzrlib.__copyright__
1787
print "http://bazaar-ng.org/"
1788
print
1789
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1790
print "you may use, modify and redistribute it under the terms of the GNU"
1791
print "General Public License version 2 or later."
2054
ui.ui_factory = save_ui
1792
2055
1793
2056
1794
2057
class cmd_version(Command):
1795
2058
"""Show version of bzr."""
2059
1796
2060
@display_command
1797
2061
def run(self):
2062
from bzrlib.version import show_version
1798
2063
show_version()
1799
2064
2065
1800
2066
class cmd_rocks(Command):
1801
2067
"""Statement of optimism."""
2068
1802
2069
hidden = True
2070
1803
2071
@display_command
1804
2072
def run(self):
1805
2073
print "it sure does!"
1806
2074
1807
2075
1808
2076
class cmd_find_merge_base(Command):
1809
"""Find and print a base revision for merging two branches.
1810
"""
2077
"""Find and print a base revision for merging two branches."""
1811
2078
# TODO: Options to specify revisions on either side, as if
1812
2079
# merging only part of the history.
1813
2080
takes_args = ['branch', 'other']
1832
2099
base_rev_id = common_ancestor(last1, last2, source)
1833
2100
1834
2101
print 'merge base is revision %s' % base_rev_id
1835
1836
return
1837
1838
if base_revno is None:
1839
raise bzrlib.errors.UnrelatedBranches()
1840
1841
print ' r%-6d in %s' % (base_revno, branch)
1842
1843
other_revno = branch2.revision_id_to_revno(base_revid)
1844
1845
print ' r%-6d in %s' % (other_revno, other)
1846
1847
2102
1848
2103
1849
2104
class cmd_merge(Command):
1850
2105
"""Perform a three-way merge.
1851
2106
1852
The branch is the branch you will merge from. By default, it will
1853
merge the latest revision. If you specify a revision, that
1854
revision will be merged. If you specify two revisions, the first
1855
will be used as a BASE, and the second one as OTHER. Revision
1856
numbers are always relative to the specified branch.
2107
The branch is the branch you will merge from. By default, it will merge
2108
the latest revision. If you specify a revision, that revision will be
2109
merged. If you specify two revisions, the first will be used as a BASE,
2110
and the second one as OTHER. Revision numbers are always relative to the
2111
specified branch.
1857
2112
1858
2113
By default, bzr will try to merge in all new work from the other
1859
2114
branch, automatically determining an appropriate base. If this
1868
2123
1869
2124
If there is no default branch set, the first merge will set it. After
1870
2125
that, you can omit the branch to use the default. To change the
1871
default, use --remember.
2126
default, use --remember. The value will only be saved if the remote
2127
location can be accessed.
1872
2128
1873
2129
Examples:
1874
2130
1883
2139
1884
2140
merge refuses to run if there are any uncommitted changes, unless
1885
2141
--force is given.
2142
2143
The following merge types are available:
1886
2144
"""
1887
2145
takes_args = ['branch?']
1888
2146
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1889
2147
Option('show-base', help="Show base revision text in "
1890
"conflicts")]
2148
"conflicts"),
2149
Option('uncommitted', help='Apply uncommitted changes'
2150
' from a working copy, instead of branch changes')]
2151
2152
def help(self):
2153
from merge import merge_type_help
2154
from inspect import getdoc
2155
return getdoc(self) + '\n' + merge_type_help()
1891
2156
1892
2157
def run(self, branch=None, revision=None, force=False, merge_type=None,
1893
show_base=False, reprocess=False, remember=False):
2158
show_base=False, reprocess=False, remember=False,
2159
uncommitted=False):
1894
2160
if merge_type is None:
1895
2161
merge_type = Merge3Merger
1896
2162
1897
2163
tree = WorkingTree.open_containing(u'.')[0]
1898
stored_loc = tree.branch.get_parent()
1899
if branch is None:
1900
if stored_loc is None:
1901
raise BzrCommandError("No merge branch known or specified.")
2164
2165
if branch is not None:
2166
try:
2167
reader = bundle.read_bundle_from_url(branch)
2168
except NotABundle:
2169
pass # Continue on considering this url a Branch
1902
2170
else:
1903
print "Using saved branch: %s" % stored_loc
1904
branch = stored_loc
2171
conflicts = merge_bundle(reader, tree, not force, merge_type,
2172
reprocess, show_base)
2173
if conflicts == 0:
2174
return 0
2175
else:
2176
return 1
1905
2177
1906
if tree.branch.get_parent() is None or remember:
1907
tree.branch.set_parent(branch)
2178
if revision is None \
2179
or len(revision) < 1 or revision[0].needs_branch():
2180
branch = self._get_remembered_parent(tree, branch, 'Merging from')
1908
2181
1909
2182
if revision is None or len(revision) < 1:
1910
base = [None, None]
1911
other = [branch, -1]
2183
if uncommitted:
2184
base = [branch, -1]
2185
other = [branch, None]
2186
else:
2187
base = [None, None]
2188
other = [branch, -1]
1912
2189
other_branch, path = Branch.open_containing(branch)
1913
2190
else:
2191
if uncommitted:
2192
raise BzrCommandError('Cannot use --uncommitted and --revision'
2193
' at the same time.')
2194
branch = revision[0].get_branch() or branch
1914
2195
if len(revision) == 1:
1915
2196
base = [None, None]
1916
2197
other_branch, path = Branch.open_containing(branch)
1920
2201
assert len(revision) == 2
1921
2202
if None in revision:
1922
2203
raise BzrCommandError(
1923
"Merge doesn't permit that revision specifier.")
1924
b, path = Branch.open_containing(branch)
1925
1926
base = [branch, revision[0].in_history(b).revno]
1927
other = [branch, revision[1].in_history(b).revno]
2204
"Merge doesn't permit empty revision specifier.")
2205
base_branch, path = Branch.open_containing(branch)
2206
branch1 = revision[1].get_branch() or branch
2207
other_branch, path1 = Branch.open_containing(branch1)
2208
if revision[0].get_branch() is not None:
2209
# then path was obtained from it, and is None.
2210
path = path1
2211
2212
base = [branch, revision[0].in_history(base_branch).revno]
2213
other = [branch1, revision[1].in_history(other_branch).revno]
2214
2215
if tree.branch.get_parent() is None or remember:
2216
tree.branch.set_parent(other_branch.base)
2217
1928
2218
if path != "":
1929
2219
interesting_files = [path]
1930
2220
else:
1931
2221
interesting_files = None
1932
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2222
pb = ui.ui_factory.nested_progress_bar()
1933
2223
try:
1934
2224
try:
1935
2225
conflict_count = merge(other, base, check_clean=(not force),
1936
merge_type=merge_type,
2226
merge_type=merge_type,
1937
2227
reprocess=reprocess,
1938
show_base=show_base,
2228
show_base=show_base,
1939
2229
pb=pb, file_list=interesting_files)
1940
2230
finally:
1941
2231
pb.finished()
1943
2233
return 1
1944
2234
else:
1945
2235
return 0
1946
except bzrlib.errors.AmbiguousBase, e:
2236
except errors.AmbiguousBase, e:
1947
2237
m = ("sorry, bzr can't determine the right merge base yet\n"
1948
2238
"candidates are:\n "
1949
2239
+ "\n ".join(e.bases)
1952
2242
"and (if you want) report this to the bzr developers\n")
1953
2243
log_error(m)
1954
2244
2245
# TODO: move up to common parent; this isn't merge-specific anymore.
2246
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2247
"""Use tree.branch's parent if none was supplied.
2248
2249
Report if the remembered location was used.
2250
"""
2251
if supplied_location is not None:
2252
return supplied_location
2253
stored_location = tree.branch.get_parent()
2254
mutter("%s", stored_location)
2255
if stored_location is None:
2256
raise BzrCommandError("No location specified or remembered")
2257
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2258
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2259
return stored_location
2260
1955
2261
1956
2262
class cmd_remerge(Command):
1957
2263
"""Redo a merge.
1958
"""
2264
2265
Use this if you want to try a different merge technique while resolving
2266
conflicts. Some merge techniques are better than others, and remerge
2267
lets you try different ones on different files.
2268
2269
The options for remerge have the same meaning and defaults as the ones for
2270
merge. The difference is that remerge can (only) be run when there is a
2271
pending merge, and it lets you specify particular files.
2272
2273
Examples:
2274
$ bzr remerge --show-base
2275
Re-do the merge of all conflicted files, and show the base text in
2276
conflict regions, in addition to the usual THIS and OTHER texts.
2277
2278
$ bzr remerge --merge-type weave --reprocess foobar
2279
Re-do the merge of "foobar", using the weave merge algorithm, with
2280
additional processing to reduce the size of conflict regions.
2281
2282
The following merge types are available:"""
1959
2283
takes_args = ['file*']
1960
2284
takes_options = ['merge-type', 'reprocess',
1961
2285
Option('show-base', help="Show base revision text in "
1962
2286
"conflicts")]
1963
2287
2288
def help(self):
2289
from merge import merge_type_help
2290
from inspect import getdoc
2291
return getdoc(self) + '\n' + merge_type_help()
2292
1964
2293
def run(self, file_list=None, merge_type=None, show_base=False,
1965
2294
reprocess=False):
1966
2295
from bzrlib.merge import merge_inner, transform_tree
1969
2298
tree, file_list = tree_files(file_list)
1970
2299
tree.lock_write()
1971
2300
try:
1972
pending_merges = tree.pending_merges()
1973
if len(pending_merges) != 1:
2301
parents = tree.get_parent_ids()
2302
if len(parents) != 2:
1974
2303
raise BzrCommandError("Sorry, remerge only works after normal"
1975
+ " merges. Not cherrypicking or"
1976
+ "multi-merges.")
2304
" merges. Not cherrypicking or"
2305
" multi-merges.")
1977
2306
repository = tree.branch.repository
1978
base_revision = common_ancestor(tree.branch.last_revision(),
1979
pending_merges[0], repository)
2307
base_revision = common_ancestor(parents[0],
2308
parents[1], repository)
1980
2309
base_tree = repository.revision_tree(base_revision)
1981
other_tree = repository.revision_tree(pending_merges[0])
2310
other_tree = repository.revision_tree(parents[1])
1982
2311
interesting_ids = None
2312
new_conflicts = []
2313
conflicts = tree.conflicts()
1983
2314
if file_list is not None:
1984
2315
interesting_ids = set()
1985
2316
for filename in file_list:
1992
2323
1993
2324
for name, ie in tree.inventory.iter_entries(file_id):
1994
2325
interesting_ids.add(ie.file_id)
2326
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
1995
2327
transform_tree(tree, tree.basis_tree(), interesting_ids)
2328
tree.set_conflicts(ConflictList(new_conflicts))
1996
2329
if file_list is None:
1997
2330
restore_files = list(tree.iter_conflicts())
1998
2331
else:
2002
2335
restore(tree.abspath(filename))
2003
2336
except NotConflicted:
2004
2337
pass
2005
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2006
this_tree=tree,
2007
interesting_ids = interesting_ids,
2008
other_rev_id=pending_merges[0],
2009
merge_type=merge_type,
2010
show_base=show_base,
2011
reprocess=reprocess)
2338
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2339
this_tree=tree,
2340
interesting_ids=interesting_ids,
2341
other_rev_id=parents[1],
2342
merge_type=merge_type,
2343
show_base=show_base,
2344
reprocess=reprocess)
2012
2345
finally:
2013
2346
tree.unlock()
2014
2347
if conflicts > 0:
2017
2350
return 0
2018
2351
2019
2352
class cmd_revert(Command):
2020
"""Reverse all changes since the last commit.
2021
2022
Only versioned files are affected. Specify filenames to revert only
2023
those files. By default, any files that are changed will be backed up
2024
first. Backup files have a '~' appended to their name.
2353
"""Revert files to a previous revision.
2354
2355
Giving a list of files will revert only those files. Otherwise, all files
2356
will be reverted. If the revision is not specified with '--revision', the
2357
last committed revision is used.
2358
2359
To remove only some changes, without reverting to a prior version, use
2360
merge instead. For example, "merge . --r-2..-3" will remove the changes
2361
introduced by -2, without affecting the changes introduced by -1. Or
2362
to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
2363
2364
By default, any files that have been manually changed will be backed up
2365
first. (Files changed only by merge are not backed up.) Backup files have
2366
'.~#~' appended to their name, where # is a number.
2367
2368
When you provide files, you can use their current pathname or the pathname
2369
from the target revision. So you can use revert to "undelete" a file by
2370
name. If you name a directory, all the contents of that directory will be
2371
reverted.
2025
2372
"""
2026
2373
takes_options = ['revision', 'no-backup']
2027
2374
takes_args = ['file*']
2043
2390
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2044
2391
else:
2045
2392
rev_id = revision[0].in_history(tree.branch).rev_id
2046
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2393
pb = ui.ui_factory.nested_progress_bar()
2047
2394
try:
2048
2395
tree.revert(file_list,
2049
2396
tree.branch.repository.revision_tree(rev_id),
2097
2444
takes_args = ['from_branch', 'to_branch']
2098
2445
def run(self, from_branch, to_branch):
2099
2446
from bzrlib.fetch import Fetcher
2100
from bzrlib.branch import Branch
2101
2447
from_b = Branch.open(from_branch)
2102
2448
to_b = Branch.open(to_branch)
2103
2449
Fetcher(to_b, from_b)
2120
2466
'show-ids',
2121
2467
'verbose'
2122
2468
]
2469
encoding_type = 'replace'
2123
2470
2471
@display_command
2124
2472
def run(self, other_branch=None, reverse=False, mine_only=False,
2125
2473
theirs_only=False, log_format=None, long=False, short=False, line=False,
2126
2474
show_ids=False, verbose=False):
2127
2475
from bzrlib.missing import find_unmerged, iter_log_data
2128
2476
from bzrlib.log import log_formatter
2129
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2477
local_branch = Branch.open_containing(u".")[0]
2130
2478
parent = local_branch.get_parent()
2131
2479
if other_branch is None:
2132
2480
other_branch = parent
2133
2481
if other_branch is None:
2134
raise BzrCommandError("No missing location known or specified.")
2482
raise BzrCommandError("No peer location known or specified.")
2135
2483
print "Using last location: " + local_branch.get_parent()
2136
remote_branch = bzrlib.branch.Branch.open(other_branch)
2137
local_branch.lock_write()
2484
remote_branch = Branch.open(other_branch)
2138
2485
if remote_branch.base == local_branch.base:
2139
2486
remote_branch = local_branch
2487
local_branch.lock_read()
2140
2488
try:
2141
2489
remote_branch.lock_read()
2142
2490
try:
2143
2491
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2144
if (log_format == None):
2145
default = bzrlib.config.BranchConfig(local_branch).log_format()
2146
log_format = get_log_format(long=long, short=short, line=line, default=default)
2147
lf = log_formatter(log_format, sys.stdout,
2492
if (log_format is None):
2493
default = local_branch.get_config().log_format()
2494
log_format = get_log_format(long=long, short=short,
2495
line=line, default=default)
2496
lf = log_formatter(log_format,
2497
to_file=self.outf,
2148
2498
show_ids=show_ids,
2149
2499
show_timezone='original')
2150
2500
if reverse is False:
2170
2520
print "Branches are up to date."
2171
2521
else:
2172
2522
status_code = 1
2173
if parent is None and other_branch is not None:
2174
local_branch.set_parent(other_branch)
2175
return status_code
2523
finally:
2524
remote_branch.unlock()
2525
finally:
2526
local_branch.unlock()
2527
if not status_code and parent is None and other_branch is not None:
2528
local_branch.lock_write()
2529
try:
2530
# handle race conditions - a parent might be set while we run.
2531
if local_branch.get_parent() is None:
2532
local_branch.set_parent(remote_branch.base)
2176
2533
finally:
2177
2534
local_branch.unlock()
2178
finally:
2179
remote_branch.unlock()
2535
return status_code
2180
2536
2181
2537
2182
2538
class cmd_plugins(Command):
2187
2543
import bzrlib.plugin
2188
2544
from inspect import getdoc
2189
2545
for name, plugin in bzrlib.plugin.all_plugins().items():
2190
if hasattr(plugin, '__path__'):
2546
if getattr(plugin, '__path__', None) is not None:
2191
2547
print plugin.__path__[0]
2192
elif hasattr(plugin, '__file__'):
2548
elif getattr(plugin, '__file__', None) is not None:
2193
2549
print plugin.__file__
2194
2550
else:
2195
print `plugin`
2551
print repr(plugin)
2196
2552
2197
2553
d = getdoc(plugin)
2198
2554
if d:
2201
2557
2202
2558
class cmd_testament(Command):
2203
2559
"""Show testament (signing-form) of a revision."""
2204
takes_options = ['revision', 'long']
2560
takes_options = ['revision',
2561
Option('long', help='Produce long-format testament'),
2562
Option('strict', help='Produce a strict-format'
2563
' testament')]
2205
2564
takes_args = ['branch?']
2206
2565
@display_command
2207
def run(self, branch=u'.', revision=None, long=False):
2208
from bzrlib.testament import Testament
2566
def run(self, branch=u'.', revision=None, long=False, strict=False):
2567
from bzrlib.testament import Testament, StrictTestament
2568
if strict is True:
2569
testament_class = StrictTestament
2570
else:
2571
testament_class = Testament
2209
2572
b = WorkingTree.open_containing(branch)[0].branch
2210
2573
b.lock_read()
2211
2574
try:
2213
2576
rev_id = b.last_revision()
2214
2577
else:
2215
2578
rev_id = revision[0].in_history(b).rev_id
2216
t = Testament.from_revision(b.repository, rev_id)
2579
t = testament_class.from_revision(b.repository, rev_id)
2217
2580
if long:
2218
2581
sys.stdout.writelines(t.as_text_lines())
2219
2582
else:
2232
2595
shown only at the top, unless the --all option is given.
2233
2596
"""
2234
2597
# TODO: annotate directories; showing when each file was last changed
2235
# TODO: annotate a previous version of a file
2236
2598
# TODO: if the working copy is modified, show annotations on that
2237
2599
# with new uncommitted lines marked
2238
aliases = ['blame', 'praise']
2600
aliases = ['ann', 'blame', 'praise']
2239
2601
takes_args = ['filename']
2240
2602
takes_options = [Option('all', help='show annotations on all lines'),
2241
2603
Option('long', help='show date in annotations'),
2604
'revision'
2242
2605
]
2243
2606
2244
2607
@display_command
2245
def run(self, filename, all=False, long=False):
2608
def run(self, filename, all=False, long=False, revision=None):
2246
2609
from bzrlib.annotate import annotate_file
2247
2610
tree, relpath = WorkingTree.open_containing(filename)
2248
2611
branch = tree.branch
2249
2612
branch.lock_read()
2250
2613
try:
2614
if revision is None:
2615
revision_id = branch.last_revision()
2616
elif len(revision) != 1:
2617
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2618
else:
2619
revision_id = revision[0].in_history(branch).rev_id
2251
2620
file_id = tree.inventory.path2id(relpath)
2252
tree = branch.repository.revision_tree(branch.last_revision())
2621
tree = branch.repository.revision_tree(revision_id)
2253
2622
file_version = tree.inventory[file_id].revision
2254
2623
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2255
2624
finally:
2265
2634
takes_options = ['revision']
2266
2635
2267
2636
def run(self, revision_id_list=None, revision=None):
2268
import bzrlib.config as config
2269
2637
import bzrlib.gpg as gpg
2270
2638
if revision_id_list is not None and revision is not None:
2271
2639
raise BzrCommandError('You can only supply one of revision_id or --revision')
2272
2640
if revision_id_list is None and revision is None:
2273
2641
raise BzrCommandError('You must supply either --revision or a revision_id')
2274
2642
b = WorkingTree.open_containing(u'.')[0].branch
2275
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2643
gpg_strategy = gpg.GPGStrategy(b.get_config())
2276
2644
if revision_id_list is not None:
2277
2645
for revision_id in revision_id_list:
2278
2646
b.repository.sign_revision(revision_id, gpg_strategy)
2318
2686
2319
2687
2320
2688
class cmd_unbind(Command):
2321
"""Bind the current branch to its parent.
2689
"""Unbind the current branch from its master branch.
2322
2690
2323
2691
After unbinding, the local branch is considered independent.
2692
All subsequent commits will be local.
2324
2693
"""
2325
2694
2326
2695
takes_args = []
2332
2701
raise BzrCommandError('Local branch is not bound')
2333
2702
2334
2703
2335
class cmd_uncommit(bzrlib.commands.Command):
2704
class cmd_uncommit(Command):
2336
2705
"""Remove the last committed revision.
2337
2706
2338
By supplying the --all flag, it will not only remove the entry
2339
from revision_history, but also remove all of the entries in the
2340
stores.
2341
2342
2707
--verbose will print out what is being removed.
2343
2708
--dry-run will go through all the motions, but not actually
2344
2709
remove anything.
2345
2710
2346
In the future, uncommit will create a changeset, which can then
2711
In the future, uncommit will create a revision bundle, which can then
2347
2712
be re-applied.
2348
2713
"""
2349
2714
2350
2715
# TODO: jam 20060108 Add an option to allow uncommit to remove
2351
# unreferenced information in 'branch-as-repostory' branches.
2716
# unreferenced information in 'branch-as-repository' branches.
2352
2717
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2353
2718
# information in shared branches as well.
2354
2719
takes_options = ['verbose', 'revision',
2357
2722
takes_args = ['location?']
2358
2723
aliases = []
2359
2724
2360
def run(self, location=None,
2725
def run(self, location=None,
2361
2726
dry_run=False, verbose=False,
2362
2727
revision=None, force=False):
2363
from bzrlib.branch import Branch
2364
from bzrlib.log import log_formatter
2728
from bzrlib.log import log_formatter, show_log
2365
2729
import sys
2366
2730
from bzrlib.uncommit import uncommit
2367
2731
2375
2739
tree = None
2376
2740
b = control.open_branch()
2377
2741
2742
rev_id = None
2378
2743
if revision is None:
2379
2744
revno = b.revno()
2380
rev_id = b.last_revision()
2381
2745
else:
2382
revno, rev_id = revision[0].in_history(b)
2746
# 'bzr uncommit -r 10' actually means uncommit
2747
# so that the final tree is at revno 10.
2748
# but bzrlib.uncommit.uncommit() actually uncommits
2749
# the revisions that are supplied.
2750
# So we need to offset it by one
2751
revno = revision[0].in_history(b).revno+1
2752
2753
if revno <= b.revno():
2754
rev_id = b.get_rev_id(revno)
2383
2755
if rev_id is None:
2384
print 'No revisions to uncommit.'
2385
2386
for r in range(revno, b.revno()+1):
2387
rev_id = b.get_rev_id(r)
2388
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2389
lf.show(r, b.repository.get_revision(rev_id), None)
2756
self.outf.write('No revisions to uncommit.\n')
2757
return 1
2758
2759
lf = log_formatter('short',
2760
to_file=self.outf,
2761
show_timezone='original')
2762
2763
show_log(b,
2764
lf,
2765
verbose=False,
2766
direction='forward',
2767
start_revision=revno,
2768
end_revision=b.revno())
2390
2769
2391
2770
if dry_run:
2392
2771
print 'Dry-run, pretending to remove the above revisions.'
2409
2788
2410
2789
CAUTION: Locks should only be broken when you are sure that the process
2411
2790
holding the lock has been stopped.
2791
2792
You can get information on what locks are open via the 'bzr info' command.
2412
2793
2413
2794
example:
2414
bzr break-lock .
2415
"""
2416
takes_args = ['location']
2417
takes_options = [Option('show',
2418
help="just show information on the lock, " \
2419
"don't break it"),
2420
]
2421
def run(self, location, show=False):
2422
raise NotImplementedError("sorry, break-lock is not complete yet; "
2423
"you can remove the 'held' directory manually to break the lock")
2795
bzr break-lock
2796
"""
2797
takes_args = ['location?']
2798
2799
def run(self, location=None, show=False):
2800
if location is None:
2801
location = u'.'
2802
control, relpath = bzrdir.BzrDir.open_containing(location)
2803
try:
2804
control.break_lock()
2805
except NotImplementedError:
2806
pass
2807
2808
2809
class cmd_wait_until_signalled(Command):
2810
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
2811
2812
This just prints a line to signal when it is ready, then blocks on stdin.
2813
"""
2814
2815
hidden = True
2816
2817
def run(self):
2818
sys.stdout.write("running\n")
2819
sys.stdout.flush()
2820
sys.stdin.readline()
2821
2822
2823
class cmd_serve(Command):
2824
"""Run the bzr server."""
2825
2826
aliases = ['server']
2827
2828
takes_options = [
2829
Option('inet',
2830
help='serve on stdin/out for use from inetd or sshd'),
2831
Option('port',
2832
help='listen for connections on nominated port of the form '
2833
'[hostname:]portnumber. Passing 0 as the port number will '
2834
'result in a dynamically allocated port.',
2835
type=str),
2836
Option('directory',
2837
help='serve contents of directory',
2838
type=unicode),
2839
Option('allow-writes',
2840
help='By default the server is a readonly server. Supplying '
2841
'--allow-writes enables write access to the contents of '
2842
'the served directory and below. '
2843
),
2844
]
2845
2846
def run(self, port=None, inet=False, directory=None, allow_writes=False):
2847
from bzrlib.transport import smart
2848
from bzrlib.transport import get_transport
2849
if directory is None:
2850
directory = os.getcwd()
2851
url = urlutils.local_path_to_url(directory)
2852
if not allow_writes:
2853
url = 'readonly+' + url
2854
t = get_transport(url)
2855
if inet:
2856
server = smart.SmartStreamServer(sys.stdin, sys.stdout, t)
2857
elif port is not None:
2858
if ':' in port:
2859
host, port = port.split(':')
2860
else:
2861
host = '127.0.0.1'
2862
server = smart.SmartTCPServer(t, host=host, port=int(port))
2863
print 'listening on port: ', server.port
2864
sys.stdout.flush()
2865
else:
2866
raise BzrCommandError("bzr serve requires one of --inet or --port")
2867
server.serve()
2424
2868
2425
2869
2426
2870
# command-line interpretation helper for merge-related commands
2463
2907
if show_base and not merge_type is Merge3Merger:
2464
2908
raise BzrCommandError("Show-base is not supported for this merge"
2465
2909
" type. %s" % merge_type)
2466
if reprocess and not merge_type is Merge3Merger:
2467
raise BzrCommandError("Reprocess is not supported for this merge"
2468
" type. %s" % merge_type)
2910
if reprocess and not merge_type.supports_reprocess:
2911
raise BzrCommandError("Conflict reduction is not supported for merge"
2912
" type %s." % merge_type)
2469
2913
if reprocess and show_base:
2470
raise BzrCommandError("Cannot reprocess and show base.")
2914
raise BzrCommandError("Cannot do conflict reduction and show base.")
2471
2915
try:
2472
2916
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2473
2917
merger.pp = ProgressPhase("Merge phase", 5, pb)
2497
2941
# we do need to load at least some information about them to know of
2498
2942
# aliases. ideally we would avoid loading the implementation until the
2499
2943
# details were needed.
2944
from bzrlib.cmd_version_info import cmd_version_info
2500
2945
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2946
from bzrlib.bundle.commands import cmd_bundle_revisions
2501
2947
from bzrlib.sign_my_commits import cmd_sign_my_commits
2502
2948
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2503
2949
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0