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 4189.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 4189.1.1
- Committer: Martin Pool
- Date: 2009-03-24 01:53:42 UTC
- mfrom: (4183.7.1 bzr.fsf_addr)
- mto: This revision was merged to the branch mainline in revision 4193.
- Revision ID: mbp@sourcefrog.net-20090324015342-y63ohyih0bcxjoct
merge update to FSF address
- files added:
- bzrlib/tests/test_http_implementations.py
- bzrlib/util/configobj/docs
- doc/en/developer-guide
- doc/es/guia-desarrollador
- doc/es/notas-version
- doc/es/referencia
- files removed:
- .testr.conf
- apport
- bzrlib/help_topics/es
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/news_merge
- bzrlib/plugins/news_merge/tests
- bzrlib/tests/per_bzrdir_colo
- bzrlib/tests/per_foreign_vcs
- bzrlib/tests/per_repository_chk
- bzrlib/tests/per_uifactory
- contrib/debian
- doc/developers/_static
- doc/developers/_templates
- doc/en/_static
- doc/en/_static/en
- doc/en/_templates
- doc/en/upgrade-guide
- doc/en/whats-new
- doc/es/_static
- doc/es/_static/es
- doc/es/_templates
- doc/ja
- doc/ja/_static
- doc/ja/_templates
- doc/ja/mini-tutorial
- doc/ja/tutorials
- doc/ja/upgrade-guide
- doc/ja/user-guide
- doc/ja/user-guide/images
- doc/ja/user-reference
- doc/ru
- doc/ru/_static
- doc/ru/_static/ru
- doc/ru/_templates
- doc/ru/mini-tutorial
- doc/ru/quick-reference
- doc/ru/tutorials
- doc/ru/user-guide
- doc/ru/user-guide/images
- tools/win32/buildout-templates
- tools/win32/buildout-templates/bin
- files renamed:
- bzrlib/_btree_serializer_pyx.pyx => bzrlib/_btree_serializer_c.pyx
- bzrlib/_dirstate_helpers_pyx.h => bzrlib/_dirstate_helpers_c.h
- bzrlib/_dirstate_helpers_pyx.pyx => bzrlib/_dirstate_helpers_c.pyx
- bzrlib/_knit_load_data_pyx.pyx => bzrlib/_knit_load_data_c.pyx
- bzrlib/help_topics/en/conflict-types.txt => bzrlib/help_topics/en/conflicts.txt
- bzrlib/tests/per_branch/ => bzrlib/tests/branch_implementations/
- bzrlib/tests/per_bzrdir/ => bzrlib/tests/bzrdir_implementations/
- bzrlib/tests/per_interrepository/ => bzrlib/tests/interrepository_implementations/
- bzrlib/tests/per_intertree/ => bzrlib/tests/intertree_implementations/
- bzrlib/tests/per_inventory/ => bzrlib/tests/inventory_implementations/
- bzrlib/tests/per_pack_repository.py => bzrlib/tests/test_pack_repository.py
- bzrlib/tests/per_transport.py => bzrlib/tests/test_transport_implementations.py
- bzrlib/tests/per_versionedfile.py => bzrlib/tests/test_versionedfile.py
- bzrlib/tests/per_tree/ => bzrlib/tests/tree_implementations/
- bzrlib/tests/per_workingtree/ => bzrlib/tests/workingtree_implementations/
- bzrlib/tests/per_tree/test_get_file_with_stat.py => bzrlib/tests/workingtree_implementations/test_get_file_with_stat.py
- bzrlib/util/_bencode_py.py => bzrlib/util/bencode.py
- doc/en/_static/en/Makefile => doc/en/quick-reference/Makefile
- doc/en/_static/en/bzr-en-quick-reference.pdf => doc/en/quick-reference/quick-start-summary.pdf
- doc/en/_static/en/bzr-en-quick-reference.png => doc/en/quick-reference/quick-start-summary.png
- doc/en/_static/en/bzr-en-quick-reference.svg => doc/en/quick-reference/quick-start-summary.svg
- doc/es/user-guide/ => doc/es/guia-usuario/
- bzrlib/help_topics/es/conflict-types.txt => doc/es/guia-usuario/resolving_conflicts.txt
- doc/es/quick-reference/ => doc/es/referencia-rapida/
- doc/es/_static/es/Makefile => doc/es/referencia-rapida/Makefile
- doc/es/_static/es/bzr-es-quick-reference.svg => doc/es/referencia-rapida/referencia-rapida.svg
- doc/es/index.txt => doc/index.es.txt
- tools/generate_docs.py => generate_docs.py
- bzrlib/doc_generate/ => tools/doc_generate/
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2005-2010 Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
31
31
bundle,
32
32
btree_index,
33
33
bzrdir,
34
directory_service,
35
34
delta,
36
35
config,
37
36
errors,
42
41
merge_directive,
43
42
osutils,
44
43
reconfigure,
45
rename_map,
46
44
revision as _mod_revision,
47
static_tuple,
48
45
symbol_versioning,
49
timestamp,
50
46
transport,
47
tree as _mod_tree,
51
48
ui,
52
49
urlutils,
53
50
views,
54
51
)
55
52
from bzrlib.branch import Branch
56
53
from bzrlib.conflicts import ConflictList
57
from bzrlib.transport import memory
58
54
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
59
55
from bzrlib.smtp_connection import SMTPConnection
60
56
from bzrlib.workingtree import WorkingTree
61
57
""")
62
58
63
from bzrlib.commands import (
64
Command,
65
builtin_command_registry,
66
display_command,
67
)
59
from bzrlib.commands import Command, display_command
68
60
from bzrlib.option import (
69
61
ListOption,
70
62
Option,
86
78
87
79
88
80
def tree_files_for_add(file_list):
89
"""
90
Return a tree and list of absolute paths from a file list.
91
92
Similar to tree_files, but add handles files a bit differently, so it a
93
custom implementation. In particular, MutableTreeTree.smart_add expects
94
absolute paths, which it immediately converts to relative paths.
95
"""
96
# FIXME Would be nice to just return the relative paths like
97
# internal_tree_files does, but there are a large number of unit tests
98
# that assume the current interface to mutabletree.smart_add
81
"""Add handles files a bit differently so it a custom implementation."""
99
82
if file_list:
100
tree, relpath = WorkingTree.open_containing(file_list[0])
83
tree = WorkingTree.open_containing(file_list[0])[0]
101
84
if tree.supports_views():
102
85
view_files = tree.views.lookup_view()
103
86
if view_files:
104
87
for filename in file_list:
105
88
if not osutils.is_inside_any(view_files, filename):
106
89
raise errors.FileOutsideView(filename, view_files)
107
file_list = file_list[:]
108
file_list[0] = tree.abspath(relpath)
109
90
else:
110
91
tree = WorkingTree.open_containing(u'.')[0]
111
92
if tree.supports_views():
113
94
if view_files:
114
95
file_list = view_files
115
96
view_str = views.view_display_str(view_files)
116
note("Ignoring files outside view. View is %s" % view_str)
97
note("ignoring files outside view: %s" % view_str)
117
98
return tree, file_list
118
99
119
100
128
109
129
110
130
111
def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):
131
"""Get a revision tree. Not suitable for commands that change the tree.
132
133
Specifically, the basis tree in dirstate trees is coupled to the dirstate
134
and doing a commit/uncommit/pull will at best fail due to changing the
135
basis revision data.
136
137
If tree is passed in, it should be already locked, for lifetime management
138
of the trees internal cached state.
139
"""
140
112
if branch is None:
141
113
branch = tree.branch
142
114
if revisions is None:
178
150
if view_files:
179
151
file_list = view_files
180
152
view_str = views.view_display_str(view_files)
181
note("Ignoring files outside view. View is %s" % view_str)
153
note("ignoring files outside view: %s" % view_str)
182
154
return tree, file_list
183
155
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
156
return tree, safe_relpath_files(tree, file_list, canonicalize,
232
204
return view_info
233
205
234
206
235
def _open_directory_or_containing_tree_or_branch(filename, directory):
236
"""Open the tree or branch containing the specified file, unless
237
the --directory option is used to specify a different branch."""
238
if directory is not None:
239
return (None, Branch.open(directory), filename)
240
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
241
242
243
207
# TODO: Make sure no commands unconditionally use the working directory as a
244
208
# branch. If a filename argument is used, the first of them should be used to
245
209
# specify the branch. (Perhaps this can be factored out into some kind of
247
211
# opens the branch?)
248
212
249
213
class cmd_status(Command):
250
__doc__ = """Display status summary.
214
"""Display status summary.
251
215
252
216
This reports on versioned and unknown files, reporting them
253
217
grouped by state. Possible states are:
273
237
unknown
274
238
Not versioned and not matching an ignore pattern.
275
239
276
Additionally for directories, symlinks and files with an executable
277
bit, Bazaar indicates their type using a trailing character: '/', '@'
278
or '*' respectively.
279
280
240
To see ignored files use 'bzr ignored'. For details on the
281
241
changes to file texts, use 'bzr diff'.
282
242
340
300
341
301
342
302
class cmd_cat_revision(Command):
343
__doc__ = """Write out metadata for a revision.
303
"""Write out metadata for a revision.
344
304
345
305
The revision to print can either be specified by a specific
346
306
revision identifier, or you can use --revision.
348
308
349
309
hidden = True
350
310
takes_args = ['revision_id?']
351
takes_options = ['directory', 'revision']
311
takes_options = ['revision']
352
312
# cat-revision is more for frontends so should be exact
353
313
encoding = 'strict'
354
314
355
def print_revision(self, revisions, revid):
356
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
357
record = stream.next()
358
if record.storage_kind == 'absent':
359
raise errors.NoSuchRevision(revisions, revid)
360
revtext = record.get_bytes_as('fulltext')
361
self.outf.write(revtext.decode('utf-8'))
362
363
315
@display_command
364
def run(self, revision_id=None, revision=None, directory=u'.'):
316
def run(self, revision_id=None, revision=None):
365
317
if revision_id is not None and revision is not None:
366
318
raise errors.BzrCommandError('You can only supply one of'
367
319
' revision_id or --revision')
368
320
if revision_id is None and revision is None:
369
321
raise errors.BzrCommandError('You must supply either'
370
322
' --revision or a revision_id')
371
b = WorkingTree.open_containing(directory)[0].branch
372
373
revisions = b.repository.revisions
374
if revisions is None:
375
raise errors.BzrCommandError('Repository %r does not support '
376
'access to raw revision texts')
377
378
b.repository.lock_read()
379
try:
380
# TODO: jam 20060112 should cat-revision always output utf-8?
381
if revision_id is not None:
382
revision_id = osutils.safe_revision_id(revision_id, warn=False)
383
try:
384
self.print_revision(revisions, revision_id)
385
except errors.NoSuchRevision:
386
msg = "The repository %s contains no revision %s." % (
387
b.repository.base, revision_id)
388
raise errors.BzrCommandError(msg)
389
elif revision is not None:
390
for rev in revision:
391
if rev is None:
392
raise errors.BzrCommandError(
393
'You cannot specify a NULL revision.')
394
rev_id = rev.as_revision_id(b)
395
self.print_revision(revisions, rev_id)
396
finally:
397
b.repository.unlock()
398
323
b = WorkingTree.open_containing(u'.')[0].branch
324
325
# TODO: jam 20060112 should cat-revision always output utf-8?
326
if revision_id is not None:
327
revision_id = osutils.safe_revision_id(revision_id, warn=False)
328
try:
329
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
330
except errors.NoSuchRevision:
331
msg = "The repository %s contains no revision %s." % (b.repository.base,
332
revision_id)
333
raise errors.BzrCommandError(msg)
334
elif revision is not None:
335
for rev in revision:
336
if rev is None:
337
raise errors.BzrCommandError('You cannot specify a NULL'
338
' revision.')
339
rev_id = rev.as_revision_id(b)
340
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
341
399
342
400
343
class cmd_dump_btree(Command):
401
__doc__ = """Dump the contents of a btree index file to stdout.
344
"""Dump the contents of a btree index file to stdout.
402
345
403
346
PATH is a btree index file, it can be any URL. This includes things like
404
347
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
468
411
for node in bt.iter_all_entries():
469
412
# Node is made up of:
470
413
# (index, key, value, [references])
471
try:
472
refs = node[3]
473
except IndexError:
474
refs_as_tuples = None
475
else:
476
refs_as_tuples = static_tuple.as_tuples(refs)
477
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
478
self.outf.write('%s\n' % (as_tuple,))
414
self.outf.write('%s\n' % (node[1:],))
479
415
480
416
481
417
class cmd_remove_tree(Command):
482
__doc__ = """Remove the working tree from a given branch/checkout.
418
"""Remove the working tree from a given branch/checkout.
483
419
484
420
Since a lightweight checkout is little more than a working tree
485
421
this will refuse to run against one.
487
423
To re-create the working tree, use "bzr checkout".
488
424
"""
489
425
_see_also = ['checkout', 'working-trees']
490
takes_args = ['location*']
426
takes_args = ['location?']
491
427
takes_options = [
492
428
Option('force',
493
429
help='Remove the working tree even if it has '
494
430
'uncommitted changes.'),
495
431
]
496
432
497
def run(self, location_list, force=False):
498
if not location_list:
499
location_list=['.']
500
501
for location in location_list:
502
d = bzrdir.BzrDir.open(location)
503
504
try:
505
working = d.open_workingtree()
506
except errors.NoWorkingTree:
507
raise errors.BzrCommandError("No working tree to remove")
508
except errors.NotLocalUrl:
509
raise errors.BzrCommandError("You cannot remove the working tree"
510
" of a remote path")
511
if not force:
512
if (working.has_changes()):
513
raise errors.UncommittedChanges(working)
514
515
if working.user_url != working.branch.user_url:
516
raise errors.BzrCommandError("You cannot remove the working tree"
517
" from a lightweight checkout")
518
519
d.destroy_workingtree()
433
def run(self, location='.', force=False):
434
d = bzrdir.BzrDir.open(location)
435
436
try:
437
working = d.open_workingtree()
438
except errors.NoWorkingTree:
439
raise errors.BzrCommandError("No working tree to remove")
440
except errors.NotLocalUrl:
441
raise errors.BzrCommandError("You cannot remove the working tree of a "
442
"remote path")
443
if not force:
444
changes = working.changes_from(working.basis_tree())
445
if changes.has_changed():
446
raise errors.UncommittedChanges(working)
447
448
working_path = working.bzrdir.root_transport.base
449
branch_path = working.branch.bzrdir.root_transport.base
450
if working_path != branch_path:
451
raise errors.BzrCommandError("You cannot remove the working tree from "
452
"a lightweight checkout")
453
454
d.destroy_workingtree()
520
455
521
456
522
457
class cmd_revno(Command):
523
__doc__ = """Show current revision number.
458
"""Show current revision number.
524
459
525
460
This is equal to the number of revisions on this branch.
526
461
"""
527
462
528
463
_see_also = ['info']
529
464
takes_args = ['location?']
530
takes_options = [
531
Option('tree', help='Show revno of working tree'),
532
]
533
465
534
466
@display_command
535
def run(self, tree=False, location=u'.'):
536
if tree:
537
try:
538
wt = WorkingTree.open_containing(location)[0]
539
self.add_cleanup(wt.lock_read().unlock)
540
except (errors.NoWorkingTree, errors.NotLocalUrl):
541
raise errors.NoWorkingTree(location)
542
revid = wt.last_revision()
543
try:
544
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
545
except errors.NoSuchRevision:
546
revno_t = ('???',)
547
revno = ".".join(str(n) for n in revno_t)
548
else:
549
b = Branch.open_containing(location)[0]
550
self.add_cleanup(b.lock_read().unlock)
551
revno = b.revno()
552
self.cleanup_now()
553
self.outf.write(str(revno) + '\n')
467
def run(self, location=u'.'):
468
self.outf.write(str(Branch.open_containing(location)[0].revno()))
469
self.outf.write('\n')
554
470
555
471
556
472
class cmd_revision_info(Command):
557
__doc__ = """Show revision number and revision id for a given revision identifier.
473
"""Show revision number and revision id for a given revision identifier.
558
474
"""
559
475
hidden = True
560
476
takes_args = ['revision_info*']
561
477
takes_options = [
562
478
'revision',
563
custom_help('directory',
479
Option('directory',
564
480
help='Branch to examine, '
565
'rather than the one containing the working directory.'),
566
Option('tree', help='Show revno of working tree'),
481
'rather than the one containing the working directory.',
482
short_name='d',
483
type=unicode,
484
),
567
485
]
568
486
569
487
@display_command
570
def run(self, revision=None, directory=u'.', tree=False,
571
revision_info_list=[]):
488
def run(self, revision=None, directory=u'.', revision_info_list=[]):
572
489
573
try:
574
wt = WorkingTree.open_containing(directory)[0]
575
b = wt.branch
576
self.add_cleanup(wt.lock_read().unlock)
577
except (errors.NoWorkingTree, errors.NotLocalUrl):
578
wt = None
579
b = Branch.open_containing(directory)[0]
580
self.add_cleanup(b.lock_read().unlock)
581
revision_ids = []
490
revs = []
582
491
if revision is not None:
583
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
492
revs.extend(revision)
584
493
if revision_info_list is not None:
585
for rev_str in revision_info_list:
586
rev_spec = RevisionSpec.from_string(rev_str)
587
revision_ids.append(rev_spec.as_revision_id(b))
588
# No arguments supplied, default to the last revision
589
if len(revision_ids) == 0:
590
if tree:
591
if wt is None:
592
raise errors.NoWorkingTree(directory)
593
revision_ids.append(wt.last_revision())
594
else:
595
revision_ids.append(b.last_revision())
596
597
revinfos = []
598
maxlen = 0
599
for revision_id in revision_ids:
494
for rev in revision_info_list:
495
revs.append(RevisionSpec.from_string(rev))
496
497
b = Branch.open_containing(directory)[0]
498
499
if len(revs) == 0:
500
revs.append(RevisionSpec.from_string('-1'))
501
502
for rev in revs:
503
revision_id = rev.as_revision_id(b)
600
504
try:
601
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
602
revno = '.'.join(str(i) for i in dotted_revno)
505
revno = '%4d' % (b.revision_id_to_revno(revision_id))
603
506
except errors.NoSuchRevision:
604
revno = '???'
605
maxlen = max(maxlen, len(revno))
606
revinfos.append([revno, revision_id])
607
608
self.cleanup_now()
609
for ri in revinfos:
610
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
507
dotted_map = b.get_revision_id_to_revno_map()
508
revno = '.'.join(str(i) for i in dotted_map[revision_id])
509
print '%s %s' % (revno, revision_id)
611
510
612
511
613
512
class cmd_add(Command):
614
__doc__ = """Add specified files or directories.
513
"""Add specified files or directories.
615
514
616
515
In non-recursive mode, all the named items are added, regardless
617
516
of whether they were previously ignored. A warning is given if
643
542
branches that will be merged later (without showing the two different
644
543
adds as a conflict). It is also useful when merging another project
645
544
into a subdirectory of this one.
646
647
Any files matching patterns in the ignore list will not be added
648
unless they are explicitly mentioned.
649
545
"""
650
546
takes_args = ['file*']
651
547
takes_options = [
659
555
help='Lookup file ids from this tree.'),
660
556
]
661
557
encoding_type = 'replace'
662
_see_also = ['remove', 'ignore']
558
_see_also = ['remove']
663
559
664
560
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
665
561
file_ids_from=None):
682
578
should_print=(not is_quiet()))
683
579
684
580
if base_tree:
685
self.add_cleanup(base_tree.lock_read().unlock)
686
tree, file_list = tree_files_for_add(file_list)
687
added, ignored = tree.smart_add(file_list, not
688
no_recurse, action=action, save=not dry_run)
689
self.cleanup_now()
581
base_tree.lock_read()
582
try:
583
file_list = self._maybe_expand_globs(file_list)
584
tree, file_list = tree_files_for_add(file_list)
585
added, ignored = tree.smart_add(file_list, not
586
no_recurse, action=action, save=not dry_run)
587
finally:
588
if base_tree is not None:
589
base_tree.unlock()
690
590
if len(ignored) > 0:
691
591
if verbose:
692
592
for glob in sorted(ignored.keys()):
693
593
for path in ignored[glob]:
694
594
self.outf.write("ignored %s matching \"%s\"\n"
695
595
% (path, glob))
596
else:
597
match_len = 0
598
for glob, paths in ignored.items():
599
match_len += len(paths)
600
self.outf.write("ignored %d file(s).\n" % match_len)
601
self.outf.write("If you wish to add some of these files,"
602
" please add them by name.\n")
696
603
697
604
698
605
class cmd_mkdir(Command):
699
__doc__ = """Create a new versioned directory.
606
"""Create a new versioned directory.
700
607
701
608
This is equivalent to creating the directory and then adding it.
702
609
"""
706
613
707
614
def run(self, dir_list):
708
615
for d in dir_list:
616
os.mkdir(d)
709
617
wt, dd = WorkingTree.open_containing(d)
710
base = os.path.dirname(dd)
711
id = wt.path2id(base)
712
if id != None:
713
os.mkdir(d)
714
wt.add([dd])
715
self.outf.write('added %s\n' % d)
716
else:
717
raise errors.NotVersionedError(path=base)
618
wt.add([dd])
619
self.outf.write('added %s\n' % d)
718
620
719
621
720
622
class cmd_relpath(Command):
721
__doc__ = """Show path of a file relative to root"""
623
"""Show path of a file relative to root"""
722
624
723
625
takes_args = ['filename']
724
626
hidden = True
733
635
734
636
735
637
class cmd_inventory(Command):
736
__doc__ = """Show inventory of the current working copy or a revision.
638
"""Show inventory of the current working copy or a revision.
737
639
738
640
It is possible to limit the output to a particular entry
739
641
type using the --kind option. For example: --kind file.
760
662
761
663
revision = _get_one_revision('inventory', revision)
762
664
work_tree, file_list = tree_files(file_list)
763
self.add_cleanup(work_tree.lock_read().unlock)
764
if revision is not None:
765
tree = revision.as_tree(work_tree.branch)
766
767
extra_trees = [work_tree]
768
self.add_cleanup(tree.lock_read().unlock)
769
else:
770
tree = work_tree
771
extra_trees = []
772
773
if file_list is not None:
774
file_ids = tree.paths2ids(file_list, trees=extra_trees,
775
require_versioned=True)
776
# find_ids_across_trees may include some paths that don't
777
# exist in 'tree'.
778
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
779
for file_id in file_ids if file_id in tree)
780
else:
781
entries = tree.inventory.entries()
782
783
self.cleanup_now()
665
work_tree.lock_read()
666
try:
667
if revision is not None:
668
tree = revision.as_tree(work_tree.branch)
669
670
extra_trees = [work_tree]
671
tree.lock_read()
672
else:
673
tree = work_tree
674
extra_trees = []
675
676
if file_list is not None:
677
file_ids = tree.paths2ids(file_list, trees=extra_trees,
678
require_versioned=True)
679
# find_ids_across_trees may include some paths that don't
680
# exist in 'tree'.
681
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
682
for file_id in file_ids if file_id in tree)
683
else:
684
entries = tree.inventory.entries()
685
finally:
686
tree.unlock()
687
if tree is not work_tree:
688
work_tree.unlock()
689
784
690
for path, entry in entries:
785
691
if kind and kind != entry.kind:
786
692
continue
792
698
793
699
794
700
class cmd_mv(Command):
795
__doc__ = """Move or rename a file.
701
"""Move or rename a file.
796
702
797
703
:Usage:
798
704
bzr mv OLDNAME NEWNAME
815
721
takes_args = ['names*']
816
722
takes_options = [Option("after", help="Move only the bzr identifier"
817
723
" of the file, because the file has already been moved."),
818
Option('auto', help='Automatically guess renames.'),
819
Option('dry-run', help='Avoid making changes when guessing renames.'),
820
724
]
821
725
aliases = ['move', 'rename']
822
726
encoding_type = 'replace'
823
727
824
def run(self, names_list, after=False, auto=False, dry_run=False):
825
if auto:
826
return self.run_auto(names_list, after, dry_run)
827
elif dry_run:
828
raise errors.BzrCommandError('--dry-run requires --auto.')
728
def run(self, names_list, after=False):
829
729
if names_list is None:
830
730
names_list = []
731
831
732
if len(names_list) < 2:
832
733
raise errors.BzrCommandError("missing file argument")
833
734
tree, rel_names = tree_files(names_list, canonicalize=False)
834
self.add_cleanup(tree.lock_tree_write().unlock)
835
self._run(tree, names_list, rel_names, after)
836
837
def run_auto(self, names_list, after, dry_run):
838
if names_list is not None and len(names_list) > 1:
839
raise errors.BzrCommandError('Only one path may be specified to'
840
' --auto.')
841
if after:
842
raise errors.BzrCommandError('--after cannot be specified with'
843
' --auto.')
844
work_tree, file_list = tree_files(names_list, default_branch='.')
845
self.add_cleanup(work_tree.lock_tree_write().unlock)
846
rename_map.RenameMap.guess_renames(work_tree, dry_run)
735
tree.lock_write()
736
try:
737
self._run(tree, names_list, rel_names, after)
738
finally:
739
tree.unlock()
847
740
848
741
def _run(self, tree, names_list, rel_names, after):
849
742
into_existing = osutils.isdir(names_list[-1])
870
763
# All entries reference existing inventory items, so fix them up
871
764
# for cicp file-systems.
872
765
rel_names = tree.get_canonical_inventory_paths(rel_names)
873
for src, dest in tree.move(rel_names[:-1], rel_names[-1], after=after):
874
if not is_quiet():
875
self.outf.write("%s => %s\n" % (src, dest))
766
for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):
767
self.outf.write("%s => %s\n" % pair)
876
768
else:
877
769
if len(names_list) != 2:
878
770
raise errors.BzrCommandError('to mv multiple files the'
922
814
dest = osutils.pathjoin(dest_parent, dest_tail)
923
815
mutter("attempting to move %s => %s", src, dest)
924
816
tree.rename_one(src, dest, after=after)
925
if not is_quiet():
926
self.outf.write("%s => %s\n" % (src, dest))
817
self.outf.write("%s => %s\n" % (src, dest))
927
818
928
819
929
820
class cmd_pull(Command):
930
__doc__ = """Turn this branch into a mirror of another branch.
821
"""Turn this branch into a mirror of another branch.
931
822
932
By default, this command only works on branches that have not diverged.
933
Branches are considered diverged if the destination branch's most recent
934
commit is one that has not been merged (directly or indirectly) into the
935
parent.
823
This command only works on branches that have not diverged. Branches are
824
considered diverged if the destination branch's most recent commit is one
825
that has not been merged (directly or indirectly) into the parent.
936
826
937
827
If branches have diverged, you can use 'bzr merge' to integrate the changes
938
828
from one into the other. Once one branch has merged, the other should
939
829
be able to pull it again.
940
830
941
If you want to replace your local changes and just want your branch to
942
match the remote one, use pull --overwrite. This will work even if the two
943
branches have diverged.
831
If you want to forget your local changes and just update your branch to
832
match the remote one, use pull --overwrite.
944
833
945
834
If there is no default location set, the first pull will set it. After
946
835
that, you can omit the location to use the default. To change the
956
845
takes_options = ['remember', 'overwrite', 'revision',
957
846
custom_help('verbose',
958
847
help='Show logs of pulled revisions.'),
959
custom_help('directory',
848
Option('directory',
960
849
help='Branch to pull into, '
961
'rather than the one containing the working directory.'),
962
Option('local',
963
help="Perform a local pull in a bound "
964
"branch. Local pulls are not applied to "
965
"the master branch."
850
'rather than the one containing the working directory.',
851
short_name='d',
852
type=unicode,
966
853
),
967
854
]
968
855
takes_args = ['location?']
970
857
971
858
def run(self, location=None, remember=False, overwrite=False,
972
859
revision=None, verbose=False,
973
directory=None, local=False):
860
directory=None):
974
861
# FIXME: too much stuff is in the command class
975
862
revision_id = None
976
863
mergeable = None
979
866
try:
980
867
tree_to = WorkingTree.open_containing(directory)[0]
981
868
branch_to = tree_to.branch
982
self.add_cleanup(tree_to.lock_write().unlock)
983
869
except errors.NoWorkingTree:
984
870
tree_to = None
985
871
branch_to = Branch.open_containing(directory)[0]
986
self.add_cleanup(branch_to.lock_write().unlock)
987
988
if local and not branch_to.get_bound_location():
989
raise errors.LocalRequiresBoundBranch()
990
872
991
873
possible_transports = []
992
874
if location is not None:
1020
902
else:
1021
903
branch_from = Branch.open(location,
1022
904
possible_transports=possible_transports)
1023
self.add_cleanup(branch_from.lock_read().unlock)
1024
905
1025
906
if branch_to.get_parent() is None or remember:
1026
907
branch_to.set_parent(branch_from.base)
1028
909
if revision is not None:
1029
910
revision_id = revision.as_revision_id(branch_from)
1030
911
1031
if tree_to is not None:
1032
view_info = _get_view_info_for_change_reporter(tree_to)
1033
change_reporter = delta._ChangeReporter(
1034
unversioned_filter=tree_to.is_ignored,
1035
view_info=view_info)
1036
result = tree_to.pull(
1037
branch_from, overwrite, revision_id, change_reporter,
1038
possible_transports=possible_transports, local=local)
1039
else:
1040
result = branch_to.pull(
1041
branch_from, overwrite, revision_id, local=local)
912
branch_to.lock_write()
913
try:
914
if tree_to is not None:
915
view_info = _get_view_info_for_change_reporter(tree_to)
916
change_reporter = delta._ChangeReporter(
917
unversioned_filter=tree_to.is_ignored, view_info=view_info)
918
result = tree_to.pull(branch_from, overwrite, revision_id,
919
change_reporter,
920
possible_transports=possible_transports)
921
else:
922
result = branch_to.pull(branch_from, overwrite, revision_id)
1042
923
1043
result.report(self.outf)
1044
if verbose and result.old_revid != result.new_revid:
1045
log.show_branch_change(
1046
branch_to, self.outf, result.old_revno,
1047
result.old_revid)
924
result.report(self.outf)
925
if verbose and result.old_revid != result.new_revid:
926
log.show_branch_change(branch_to, self.outf, result.old_revno,
927
result.old_revid)
928
finally:
929
branch_to.unlock()
1048
930
1049
931
1050
932
class cmd_push(Command):
1051
__doc__ = """Update a mirror of this branch.
933
"""Update a mirror of this branch.
1052
934
1053
935
The target branch will not have its working tree populated because this
1054
936
is both expensive, and is not supported on remote file systems.
1078
960
Option('create-prefix',
1079
961
help='Create the path leading up to the branch '
1080
962
'if it does not already exist.'),
1081
custom_help('directory',
963
Option('directory',
1082
964
help='Branch to push from, '
1083
'rather than the one containing the working directory.'),
965
'rather than the one containing the working directory.',
966
short_name='d',
967
type=unicode,
968
),
1084
969
Option('use-existing-dir',
1085
970
help='By default push will fail if the target'
1086
971
' directory exists, but does not already'
1094
979
'for the commit history. Only the work not present in the '
1095
980
'referenced branch is included in the branch created.',
1096
981
type=unicode),
1097
Option('strict',
1098
help='Refuse to push if there are uncommitted changes in'
1099
' the working tree, --no-strict disables the check.'),
1100
982
]
1101
983
takes_args = ['location?']
1102
984
encoding_type = 'replace'
1104
986
def run(self, location=None, remember=False, overwrite=False,
1105
987
create_prefix=False, verbose=False, revision=None,
1106
988
use_existing_dir=False, directory=None, stacked_on=None,
1107
stacked=False, strict=None):
989
stacked=False):
1108
990
from bzrlib.push import _show_push_branch
1109
991
992
# Get the source branch and revision_id
1110
993
if directory is None:
1111
994
directory = '.'
1112
# Get the source branch
1113
(tree, br_from,
1114
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1115
# Get the tip's revision_id
995
br_from = Branch.open_containing(directory)[0]
1116
996
revision = _get_one_revision('push', revision)
1117
997
if revision is not None:
1118
998
revision_id = revision.in_history(br_from).rev_id
1119
999
else:
1120
revision_id = None
1121
if tree is not None and revision_id is None:
1122
tree.check_changed_or_out_of_date(
1123
strict, 'push_strict',
1124
more_error='Use --no-strict to force the push.',
1125
more_warning='Uncommitted changes will not be pushed.')
1000
revision_id = br_from.last_revision()
1001
1126
1002
# Get the stacked_on branch, if any
1127
1003
if stacked_on is not None:
1128
1004
stacked_on = urlutils.normalize_url(stacked_on)
1160
1036
1161
1037
1162
1038
class cmd_branch(Command):
1163
__doc__ = """Create a new branch that is a copy of an existing branch.
1039
"""Create a new copy of a branch.
1164
1040
1165
1041
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1166
1042
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1179
1055
help='Hard-link working tree files where possible.'),
1180
1056
Option('no-tree',
1181
1057
help="Create a branch without a working-tree."),
1182
Option('switch',
1183
help="Switch the checkout in the current directory "
1184
"to the new branch."),
1185
1058
Option('stacked',
1186
1059
help='Create a stacked branch referring to the source branch. '
1187
1060
'The new branch will depend on the availability of the source '
1188
1061
'branch for all operations.'),
1189
1062
Option('standalone',
1190
1063
help='Do not use a shared repository, even if available.'),
1191
Option('use-existing-dir',
1192
help='By default branch will fail if the target'
1193
' directory exists, but does not already'
1194
' have a control directory. This flag will'
1195
' allow branch to proceed.'),
1196
Option('bind',
1197
help="Bind new branch to from location."),
1198
1064
]
1199
1065
aliases = ['get', 'clone']
1200
1066
1201
1067
def run(self, from_location, to_location=None, revision=None,
1202
hardlink=False, stacked=False, standalone=False, no_tree=False,
1203
use_existing_dir=False, switch=False, bind=False):
1204
from bzrlib import switch as _mod_switch
1068
hardlink=False, stacked=False, standalone=False, no_tree=False):
1205
1069
from bzrlib.tag import _merge_tags_if_possible
1070
1206
1071
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1207
1072
from_location)
1208
1073
revision = _get_one_revision('branch', revision)
1209
self.add_cleanup(br_from.lock_read().unlock)
1210
if revision is not None:
1211
revision_id = revision.as_revision_id(br_from)
1212
else:
1213
# FIXME - wt.last_revision, fallback to branch, fall back to
1214
# None or perhaps NULL_REVISION to mean copy nothing
1215
# RBC 20060209
1216
revision_id = br_from.last_revision()
1217
if to_location is None:
1218
to_location = urlutils.derive_to_location(from_location)
1219
to_transport = transport.get_transport(to_location)
1074
br_from.lock_read()
1220
1075
try:
1221
to_transport.mkdir('.')
1222
except errors.FileExists:
1223
if not use_existing_dir:
1224
raise errors.BzrCommandError('Target directory "%s" '
1225
'already exists.' % to_location)
1076
if revision is not None:
1077
revision_id = revision.as_revision_id(br_from)
1226
1078
else:
1227
try:
1228
bzrdir.BzrDir.open_from_transport(to_transport)
1229
except errors.NotBranchError:
1230
pass
1231
else:
1232
raise errors.AlreadyBranchError(to_location)
1233
except errors.NoSuchFile:
1234
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1235
% to_location)
1236
try:
1237
# preserve whatever source format we have.
1238
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1239
possible_transports=[to_transport],
1240
accelerator_tree=accelerator_tree,
1241
hardlink=hardlink, stacked=stacked,
1242
force_new_repo=standalone,
1243
create_tree_if_local=not no_tree,
1244
source_branch=br_from)
1245
branch = dir.open_branch()
1246
except errors.NoSuchRevision:
1247
to_transport.delete_tree('.')
1248
msg = "The branch %s has no revision %s." % (from_location,
1249
revision)
1250
raise errors.BzrCommandError(msg)
1251
_merge_tags_if_possible(br_from, branch)
1252
# If the source branch is stacked, the new branch may
1253
# be stacked whether we asked for that explicitly or not.
1254
# We therefore need a try/except here and not just 'if stacked:'
1255
try:
1256
note('Created new stacked branch referring to %s.' %
1257
branch.get_stacked_on_url())
1258
except (errors.NotStacked, errors.UnstackableBranchFormat,
1259
errors.UnstackableRepositoryFormat), e:
1260
note('Branched %d revision(s).' % branch.revno())
1261
if bind:
1262
# Bind to the parent
1263
parent_branch = Branch.open(from_location)
1264
branch.bind(parent_branch)
1265
note('New branch bound to %s' % from_location)
1266
if switch:
1267
# Switch to the new branch
1268
wt, _ = WorkingTree.open_containing('.')
1269
_mod_switch.switch(wt.bzrdir, branch)
1270
note('Switched to branch: %s',
1271
urlutils.unescape_for_display(branch.base, 'utf-8'))
1079
# FIXME - wt.last_revision, fallback to branch, fall back to
1080
# None or perhaps NULL_REVISION to mean copy nothing
1081
# RBC 20060209
1082
revision_id = br_from.last_revision()
1083
if to_location is None:
1084
to_location = urlutils.derive_to_location(from_location)
1085
to_transport = transport.get_transport(to_location)
1086
try:
1087
to_transport.mkdir('.')
1088
except errors.FileExists:
1089
raise errors.BzrCommandError('Target directory "%s" already'
1090
' exists.' % to_location)
1091
except errors.NoSuchFile:
1092
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1093
% to_location)
1094
try:
1095
# preserve whatever source format we have.
1096
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1097
possible_transports=[to_transport],
1098
accelerator_tree=accelerator_tree,
1099
hardlink=hardlink, stacked=stacked,
1100
force_new_repo=standalone,
1101
create_tree_if_local=not no_tree,
1102
source_branch=br_from)
1103
branch = dir.open_branch()
1104
except errors.NoSuchRevision:
1105
to_transport.delete_tree('.')
1106
msg = "The branch %s has no revision %s." % (from_location,
1107
revision)
1108
raise errors.BzrCommandError(msg)
1109
_merge_tags_if_possible(br_from, branch)
1110
# If the source branch is stacked, the new branch may
1111
# be stacked whether we asked for that explicitly or not.
1112
# We therefore need a try/except here and not just 'if stacked:'
1113
try:
1114
note('Created new stacked branch referring to %s.' %
1115
branch.get_stacked_on_url())
1116
except (errors.NotStacked, errors.UnstackableBranchFormat,
1117
errors.UnstackableRepositoryFormat), e:
1118
note('Branched %d revision(s).' % branch.revno())
1119
finally:
1120
br_from.unlock()
1272
1121
1273
1122
1274
1123
class cmd_checkout(Command):
1275
__doc__ = """Create a new checkout of an existing branch.
1124
"""Create a new checkout of an existing branch.
1276
1125
1277
1126
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1278
1127
the branch found in '.'. This is useful if you have removed the working tree
1341
1190
1342
1191
1343
1192
class cmd_renames(Command):
1344
__doc__ = """Show list of renamed files.
1193
"""Show list of renamed files.
1345
1194
"""
1346
1195
# TODO: Option to show renames between two historical versions.
1347
1196
1352
1201
@display_command
1353
1202
def run(self, dir=u'.'):
1354
1203
tree = WorkingTree.open_containing(dir)[0]
1355
self.add_cleanup(tree.lock_read().unlock)
1356
new_inv = tree.inventory
1357
old_tree = tree.basis_tree()
1358
self.add_cleanup(old_tree.lock_read().unlock)
1359
old_inv = old_tree.inventory
1360
renames = []
1361
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1362
for f, paths, c, v, p, n, k, e in iterator:
1363
if paths[0] == paths[1]:
1364
continue
1365
if None in (paths):
1366
continue
1367
renames.append(paths)
1368
renames.sort()
1369
for old_name, new_name in renames:
1370
self.outf.write("%s => %s\n" % (old_name, new_name))
1204
tree.lock_read()
1205
try:
1206
new_inv = tree.inventory
1207
old_tree = tree.basis_tree()
1208
old_tree.lock_read()
1209
try:
1210
old_inv = old_tree.inventory
1211
renames = []
1212
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1213
for f, paths, c, v, p, n, k, e in iterator:
1214
if paths[0] == paths[1]:
1215
continue
1216
if None in (paths):
1217
continue
1218
renames.append(paths)
1219
renames.sort()
1220
for old_name, new_name in renames:
1221
self.outf.write("%s => %s\n" % (old_name, new_name))
1222
finally:
1223
old_tree.unlock()
1224
finally:
1225
tree.unlock()
1371
1226
1372
1227
1373
1228
class cmd_update(Command):
1374
__doc__ = """Update a tree to have the latest code committed to its branch.
1229
"""Update a tree to have the latest code committed to its branch.
1375
1230
1376
1231
This will perform a merge into the working tree, and may generate
1377
1232
conflicts. If you have any local changes, you will still
1379
1234
1380
1235
If you want to discard your local changes, you can just do a
1381
1236
'bzr revert' instead of 'bzr commit' after the update.
1382
1383
If the tree's branch is bound to a master branch, it will also update
1384
the branch from the master.
1385
1237
"""
1386
1238
1387
1239
_see_also = ['pull', 'working-trees', 'status-flags']
1388
1240
takes_args = ['dir?']
1389
takes_options = ['revision']
1390
1241
aliases = ['up']
1391
1242
1392
def run(self, dir='.', revision=None):
1393
if revision is not None and len(revision) != 1:
1394
raise errors.BzrCommandError(
1395
"bzr update --revision takes exactly one revision")
1243
def run(self, dir='.'):
1396
1244
tree = WorkingTree.open_containing(dir)[0]
1397
branch = tree.branch
1398
1245
possible_transports = []
1399
master = branch.get_master_branch(
1246
master = tree.branch.get_master_branch(
1400
1247
possible_transports=possible_transports)
1401
1248
if master is not None:
1402
branch_location = master.base
1403
1249
tree.lock_write()
1404
1250
else:
1405
branch_location = tree.branch.base
1406
1251
tree.lock_tree_write()
1407
self.add_cleanup(tree.unlock)
1408
# get rid of the final '/' and be ready for display
1409
branch_location = urlutils.unescape_for_display(
1410
branch_location.rstrip('/'),
1411
self.outf.encoding)
1412
existing_pending_merges = tree.get_parent_ids()[1:]
1413
if master is None:
1414
old_tip = None
1415
else:
1416
# may need to fetch data into a heavyweight checkout
1417
# XXX: this may take some time, maybe we should display a
1418
# message
1419
old_tip = branch.update(possible_transports)
1420
if revision is not None:
1421
revision_id = revision[0].as_revision_id(branch)
1422
else:
1423
revision_id = branch.last_revision()
1424
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1425
revno = branch.revision_id_to_dotted_revno(revision_id)
1426
note("Tree is up to date at revision %s of branch %s" %
1427
('.'.join(map(str, revno)), branch_location))
1428
return 0
1429
view_info = _get_view_info_for_change_reporter(tree)
1430
change_reporter = delta._ChangeReporter(
1431
unversioned_filter=tree.is_ignored,
1432
view_info=view_info)
1433
1252
try:
1253
existing_pending_merges = tree.get_parent_ids()[1:]
1254
last_rev = _mod_revision.ensure_null(tree.last_revision())
1255
if last_rev == _mod_revision.ensure_null(
1256
tree.branch.last_revision()):
1257
# may be up to date, check master too.
1258
if master is None or last_rev == _mod_revision.ensure_null(
1259
master.last_revision()):
1260
revno = tree.branch.revision_id_to_revno(last_rev)
1261
note("Tree is up to date at revision %d." % (revno,))
1262
return 0
1263
view_info = _get_view_info_for_change_reporter(tree)
1434
1264
conflicts = tree.update(
1435
change_reporter,
1436
possible_transports=possible_transports,
1437
revision=revision_id,
1438
old_tip=old_tip)
1439
except errors.NoSuchRevision, e:
1440
raise errors.BzrCommandError(
1441
"branch has no revision %s\n"
1442
"bzr update --revision only works"
1443
" for a revision in the branch history"
1444
% (e.revision))
1445
revno = tree.branch.revision_id_to_dotted_revno(
1446
_mod_revision.ensure_null(tree.last_revision()))
1447
note('Updated to revision %s of branch %s' %
1448
('.'.join(map(str, revno)), branch_location))
1449
parent_ids = tree.get_parent_ids()
1450
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1451
note('Your local commits will now show as pending merges with '
1452
"'bzr status', and can be committed with 'bzr commit'.")
1453
if conflicts != 0:
1454
return 1
1455
else:
1456
return 0
1265
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1266
view_info=view_info), possible_transports=possible_transports)
1267
revno = tree.branch.revision_id_to_revno(
1268
_mod_revision.ensure_null(tree.last_revision()))
1269
note('Updated to revision %d.' % (revno,))
1270
if tree.get_parent_ids()[1:] != existing_pending_merges:
1271
note('Your local commits will now show as pending merges with '
1272
"'bzr status', and can be committed with 'bzr commit'.")
1273
if conflicts != 0:
1274
return 1
1275
else:
1276
return 0
1277
finally:
1278
tree.unlock()
1457
1279
1458
1280
1459
1281
class cmd_info(Command):
1460
__doc__ = """Show information about a working tree, branch or repository.
1282
"""Show information about a working tree, branch or repository.
1461
1283
1462
1284
This command will show all known locations and formats associated to the
1463
1285
tree, branch or repository.
1478
1300
basic statistics (like the number of files in the working tree and
1479
1301
number of revisions in the branch and repository):
1480
1302
1481
bzr info -v
1303
bzr -v info
1482
1304
1483
1305
Display the above together with number of committers to the branch:
1484
1306
1485
bzr info -vv
1307
bzr -vv info
1486
1308
"""
1487
1309
_see_also = ['revno', 'working-trees', 'repositories']
1488
1310
takes_args = ['location?']
1501
1323
1502
1324
1503
1325
class cmd_remove(Command):
1504
__doc__ = """Remove files or directories.
1326
"""Remove files or directories.
1505
1327
1506
1328
This makes bzr stop tracking changes to the specified files. bzr will delete
1507
1329
them if they can easily be recovered using revert. If no options or
1516
1338
title='Deletion Strategy', value_switches=True, enum_switch=False,
1517
1339
safe='Only delete files if they can be'
1518
1340
' safely recovered (default).',
1519
keep='Delete from bzr but leave the working copy.',
1341
keep="Don't delete any files.",
1520
1342
force='Delete all the specified files, even if they can not be '
1521
1343
'recovered and even if they are non-empty directories.')]
1522
1344
aliases = ['rm', 'del']
1529
1351
if file_list is not None:
1530
1352
file_list = [f for f in file_list]
1531
1353
1532
self.add_cleanup(tree.lock_write().unlock)
1533
# Heuristics should probably all move into tree.remove_smart or
1534
# some such?
1535
if new:
1536
added = tree.changes_from(tree.basis_tree(),
1537
specific_files=file_list).added
1538
file_list = sorted([f[0] for f in added], reverse=True)
1539
if len(file_list) == 0:
1540
raise errors.BzrCommandError('No matching files.')
1541
elif file_list is None:
1542
# missing files show up in iter_changes(basis) as
1543
# versioned-with-no-kind.
1544
missing = []
1545
for change in tree.iter_changes(tree.basis_tree()):
1546
# Find paths in the working tree that have no kind:
1547
if change[1][1] is not None and change[6][1] is None:
1548
missing.append(change[1][1])
1549
file_list = sorted(missing, reverse=True)
1550
file_deletion_strategy = 'keep'
1551
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1552
keep_files=file_deletion_strategy=='keep',
1553
force=file_deletion_strategy=='force')
1354
tree.lock_write()
1355
try:
1356
# Heuristics should probably all move into tree.remove_smart or
1357
# some such?
1358
if new:
1359
added = tree.changes_from(tree.basis_tree(),
1360
specific_files=file_list).added
1361
file_list = sorted([f[0] for f in added], reverse=True)
1362
if len(file_list) == 0:
1363
raise errors.BzrCommandError('No matching files.')
1364
elif file_list is None:
1365
# missing files show up in iter_changes(basis) as
1366
# versioned-with-no-kind.
1367
missing = []
1368
for change in tree.iter_changes(tree.basis_tree()):
1369
# Find paths in the working tree that have no kind:
1370
if change[1][1] is not None and change[6][1] is None:
1371
missing.append(change[1][1])
1372
file_list = sorted(missing, reverse=True)
1373
file_deletion_strategy = 'keep'
1374
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1375
keep_files=file_deletion_strategy=='keep',
1376
force=file_deletion_strategy=='force')
1377
finally:
1378
tree.unlock()
1554
1379
1555
1380
1556
1381
class cmd_file_id(Command):
1557
__doc__ = """Print file_id of a particular file or directory.
1382
"""Print file_id of a particular file or directory.
1558
1383
1559
1384
The file_id is assigned when the file is first added and remains the
1560
1385
same through all revisions where the file exists, even when it is
1576
1401
1577
1402
1578
1403
class cmd_file_path(Command):
1579
__doc__ = """Print path of file_ids to a file or directory.
1404
"""Print path of file_ids to a file or directory.
1580
1405
1581
1406
This prints one line for each directory down to the target,
1582
1407
starting at the branch root.
1598
1423
1599
1424
1600
1425
class cmd_reconcile(Command):
1601
__doc__ = """Reconcile bzr metadata in a branch.
1426
"""Reconcile bzr metadata in a branch.
1602
1427
1603
1428
This can correct data mismatches that may have been caused by
1604
1429
previous ghost operations or bzr upgrades. You should only
1626
1451
1627
1452
1628
1453
class cmd_revision_history(Command):
1629
__doc__ = """Display the list of revision ids on a branch."""
1454
"""Display the list of revision ids on a branch."""
1630
1455
1631
1456
_see_also = ['log']
1632
1457
takes_args = ['location?']
1642
1467
1643
1468
1644
1469
class cmd_ancestry(Command):
1645
__doc__ = """List all revisions merged into this branch."""
1470
"""List all revisions merged into this branch."""
1646
1471
1647
1472
_see_also = ['log', 'revision-history']
1648
1473
takes_args = ['location?']
1667
1492
1668
1493
1669
1494
class cmd_init(Command):
1670
__doc__ = """Make a directory into a versioned branch.
1495
"""Make a directory into a versioned branch.
1671
1496
1672
1497
Use this to create an empty branch, or before importing an
1673
1498
existing project.
1701
1526
lazy_registry=('bzrlib.bzrdir', 'format_registry'),
1702
1527
converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
1703
1528
value_switches=True,
1704
title="Branch format",
1529
title="Branch Format",
1705
1530
),
1706
1531
Option('append-revisions-only',
1707
1532
help='Never change revnos or the existing log.'
1730
1555
"\nYou may supply --create-prefix to create all"
1731
1556
" leading parent directories."
1732
1557
% location)
1733
to_transport.create_prefix()
1558
_create_prefix(to_transport)
1734
1559
1735
1560
try:
1736
1561
a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
1754
1579
branch.set_append_revisions_only(True)
1755
1580
except errors.UpgradeRequired:
1756
1581
raise errors.BzrCommandError('This branch format cannot be set'
1757
' to append-revisions-only. Try --default.')
1582
' to append-revisions-only. Try --experimental-branch6')
1758
1583
if not is_quiet():
1759
1584
from bzrlib.info import describe_layout, describe_format
1760
1585
try:
1776
1601
1777
1602
1778
1603
class cmd_init_repository(Command):
1779
__doc__ = """Create a shared repository for branches to share storage space.
1604
"""Create a shared repository to hold branches.
1780
1605
1781
1606
New branches created under the repository directory will store their
1782
revisions in the repository, not in the branch directory. For branches
1783
with shared history, this reduces the amount of storage needed and
1784
speeds up the creation of new branches.
1607
revisions in the repository, not in the branch directory.
1785
1608
1786
If the --no-trees option is given then the branches in the repository
1787
will not have working trees by default. They will still exist as
1788
directories on disk, but they will not have separate copies of the
1789
files at a certain revision. This can be useful for repositories that
1790
store branches which are interacted with through checkouts or remote
1791
branches, such as on a server.
1609
If the --no-trees option is used then the branches in the repository
1610
will not have working trees by default.
1792
1611
1793
1612
:Examples:
1794
Create a shared repository holding just branches::
1613
Create a shared repositories holding just branches::
1795
1614
1796
1615
bzr init-repo --no-trees repo
1797
1616
bzr init repo/trunk
1836
1655
1837
1656
1838
1657
class cmd_diff(Command):
1839
__doc__ = """Show differences in the working tree, between revisions or branches.
1658
"""Show differences in the working tree, between revisions or branches.
1840
1659
1841
1660
If no arguments are given, all changes for the current tree are listed.
1842
1661
If files are given, only the changes in those files are listed.
1863
1682
1864
1683
bzr diff -r1
1865
1684
1866
Difference between revision 3 and revision 1::
1867
1868
bzr diff -r1..3
1869
1870
Difference between revision 3 and revision 1 for branch xxx::
1871
1872
bzr diff -r1..3 xxx
1873
1874
To see the changes introduced in revision X::
1875
1876
bzr diff -cX
1877
1878
Note that in the case of a merge, the -c option shows the changes
1879
compared to the left hand parent. To see the changes against
1880
another parent, use::
1881
1882
bzr diff -r<chosen_parent>..X
1883
1884
The changes introduced by revision 2 (equivalent to -r1..2)::
1885
1886
bzr diff -c2
1685
Difference between revision 2 and revision 1::
1686
1687
bzr diff -r1..2
1688
1689
Difference between revision 2 and revision 1 for branch xxx::
1690
1691
bzr diff -r1..2 xxx
1887
1692
1888
1693
Show just the differences for file NEWS::
1889
1694
1928
1733
help='Use this command to compare files.',
1929
1734
type=unicode,
1930
1735
),
1931
RegistryOption('format',
1932
help='Diff format to use.',
1933
lazy_registry=('bzrlib.diff', 'format_registry'),
1934
value_switches=False, title='Diff format'),
1935
1736
]
1936
1737
aliases = ['di', 'dif']
1937
1738
encoding_type = 'exact'
1938
1739
1939
1740
@display_command
1940
1741
def run(self, revision=None, file_list=None, diff_options=None,
1941
prefix=None, old=None, new=None, using=None, format=None):
1942
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1943
show_diff_trees)
1742
prefix=None, old=None, new=None, using=None):
1743
from bzrlib.diff import _get_trees_to_diff, show_diff_trees
1944
1744
1945
1745
if (prefix is None) or (prefix == '0'):
1946
1746
# diff -p0 format
1960
1760
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1961
1761
' one or two revision specifiers')
1962
1762
1963
if using is not None and format is not None:
1964
raise errors.BzrCommandError('--using and --format are mutually '
1965
'exclusive.')
1966
1967
(old_tree, new_tree,
1968
old_branch, new_branch,
1969
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1970
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1763
old_tree, new_tree, specific_files, extra_trees = \
1764
_get_trees_to_diff(file_list, revision, old, new,
1765
apply_view=True)
1971
1766
return show_diff_trees(old_tree, new_tree, sys.stdout,
1972
1767
specific_files=specific_files,
1973
1768
external_diff_options=diff_options,
1974
1769
old_label=old_label, new_label=new_label,
1975
extra_trees=extra_trees, using=using,
1976
format_cls=format)
1770
extra_trees=extra_trees, using=using)
1977
1771
1978
1772
1979
1773
class cmd_deleted(Command):
1980
__doc__ = """List files deleted in the working tree.
1774
"""List files deleted in the working tree.
1981
1775
"""
1982
1776
# TODO: Show files deleted since a previous revision, or
1983
1777
# between two revisions.
1986
1780
# level of effort but possibly much less IO. (Or possibly not,
1987
1781
# if the directories are very large...)
1988
1782
_see_also = ['status', 'ls']
1989
takes_options = ['directory', 'show-ids']
1783
takes_options = ['show-ids']
1990
1784
1991
1785
@display_command
1992
def run(self, show_ids=False, directory=u'.'):
1993
tree = WorkingTree.open_containing(directory)[0]
1994
self.add_cleanup(tree.lock_read().unlock)
1995
old = tree.basis_tree()
1996
self.add_cleanup(old.lock_read().unlock)
1997
for path, ie in old.inventory.iter_entries():
1998
if not tree.has_id(ie.file_id):
1999
self.outf.write(path)
2000
if show_ids:
2001
self.outf.write(' ')
2002
self.outf.write(ie.file_id)
2003
self.outf.write('\n')
1786
def run(self, show_ids=False):
1787
tree = WorkingTree.open_containing(u'.')[0]
1788
tree.lock_read()
1789
try:
1790
old = tree.basis_tree()
1791
old.lock_read()
1792
try:
1793
for path, ie in old.inventory.iter_entries():
1794
if not tree.has_id(ie.file_id):
1795
self.outf.write(path)
1796
if show_ids:
1797
self.outf.write(' ')
1798
self.outf.write(ie.file_id)
1799
self.outf.write('\n')
1800
finally:
1801
old.unlock()
1802
finally:
1803
tree.unlock()
2004
1804
2005
1805
2006
1806
class cmd_modified(Command):
2007
__doc__ = """List files modified in working tree.
1807
"""List files modified in working tree.
2008
1808
"""
2009
1809
2010
1810
hidden = True
2011
1811
_see_also = ['status', 'ls']
2012
takes_options = ['directory', 'null']
1812
takes_options = [
1813
Option('null',
1814
help='Write an ascii NUL (\\0) separator '
1815
'between files rather than a newline.')
1816
]
2013
1817
2014
1818
@display_command
2015
def run(self, null=False, directory=u'.'):
2016
tree = WorkingTree.open_containing(directory)[0]
1819
def run(self, null=False):
1820
tree = WorkingTree.open_containing(u'.')[0]
2017
1821
td = tree.changes_from(tree.basis_tree())
2018
1822
for path, id, kind, text_modified, meta_modified in td.modified:
2019
1823
if null:
2023
1827
2024
1828
2025
1829
class cmd_added(Command):
2026
__doc__ = """List files added in working tree.
1830
"""List files added in working tree.
2027
1831
"""
2028
1832
2029
1833
hidden = True
2030
1834
_see_also = ['status', 'ls']
2031
takes_options = ['directory', 'null']
1835
takes_options = [
1836
Option('null',
1837
help='Write an ascii NUL (\\0) separator '
1838
'between files rather than a newline.')
1839
]
2032
1840
2033
1841
@display_command
2034
def run(self, null=False, directory=u'.'):
2035
wt = WorkingTree.open_containing(directory)[0]
2036
self.add_cleanup(wt.lock_read().unlock)
2037
basis = wt.basis_tree()
2038
self.add_cleanup(basis.lock_read().unlock)
2039
basis_inv = basis.inventory
2040
inv = wt.inventory
2041
for file_id in inv:
2042
if file_id in basis_inv:
2043
continue
2044
if inv.is_root(file_id) and len(basis_inv) == 0:
2045
continue
2046
path = inv.id2path(file_id)
2047
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2048
continue
2049
if null:
2050
self.outf.write(path + '\0')
2051
else:
2052
self.outf.write(osutils.quotefn(path) + '\n')
1842
def run(self, null=False):
1843
wt = WorkingTree.open_containing(u'.')[0]
1844
wt.lock_read()
1845
try:
1846
basis = wt.basis_tree()
1847
basis.lock_read()
1848
try:
1849
basis_inv = basis.inventory
1850
inv = wt.inventory
1851
for file_id in inv:
1852
if file_id in basis_inv:
1853
continue
1854
if inv.is_root(file_id) and len(basis_inv) == 0:
1855
continue
1856
path = inv.id2path(file_id)
1857
if not os.access(osutils.abspath(path), os.F_OK):
1858
continue
1859
if null:
1860
self.outf.write(path + '\0')
1861
else:
1862
self.outf.write(osutils.quotefn(path) + '\n')
1863
finally:
1864
basis.unlock()
1865
finally:
1866
wt.unlock()
2053
1867
2054
1868
2055
1869
class cmd_root(Command):
2056
__doc__ = """Show the tree root directory.
1870
"""Show the tree root directory.
2057
1871
2058
1872
The root is the nearest enclosing directory with a .bzr control
2059
1873
directory."""
2083
1897
2084
1898
2085
1899
class cmd_log(Command):
2086
__doc__ = """Show historical log for a branch or subset of a branch.
1900
"""Show historical log for a branch or subset of a branch.
2087
1901
2088
1902
log is bzr's default tool for exploring the history of a branch.
2089
1903
The branch to use is taken from the first parameter. If no parameters
2118
1932
--show-ids display revision-ids (and file-ids), not just revnos
2119
1933
2120
1934
Note that the default number of levels to display is a function of the
2121
log format. If the -n option is not used, the standard log formats show
2122
just the top level (mainline).
1935
log format. If the -n option is not used, ``short`` and ``line`` show
1936
just the top level (mainline) while ``long`` shows all levels of merged
1937
revisions.
2123
1938
2124
1939
Status summaries are shown using status flags like A, M, etc. To see
2125
1940
the changes explained using words like ``added`` and ``modified``
2161
1976
2162
1977
:Path filtering:
2163
1978
2164
If parameters are given and the first one is not a branch, the log
2165
will be filtered to show only those revisions that changed the
2166
nominated files or directories.
1979
If a parameter is given and it's not a branch, the log will be filtered
1980
to show only those revisions that changed the nominated file or
1981
directory.
2167
1982
2168
1983
Filenames are interpreted within their historical context. To log a
2169
1984
deleted file, specify a revision range so that the file existed at
2192
2007
explicitly ask for this (and no way to stop logging a file back
2193
2008
until it was last renamed).
2194
2009
2010
Note: If the path is a directory, only revisions that directly changed
2011
that directory object are currently shown. This is considered a bug.
2012
(Support for filtering against multiple files and for files within a
2013
directory is under development.)
2014
2195
2015
:Other filtering:
2196
2016
2197
2017
The --message option can be used for finding revisions that match a
2200
2020
:Tips & tricks:
2201
2021
2202
2022
GUI tools and IDEs are often better at exploring history than command
2203
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2204
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2205
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2206
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2023
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2024
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2025
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2026
2027
Web interfaces are often better at exploring history than command line
2028
tools, particularly for branches on servers. You may prefer Loggerhead
2029
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2207
2030
2208
2031
You may find it useful to add the aliases below to ``bazaar.conf``::
2209
2032
2210
2033
[ALIASES]
2211
tip = log -r-1
2212
top = log -l10 --line
2213
show = log -v -p
2034
tip = log -r-1 -n1
2035
top = log -r-10.. --short --forward
2036
show = log -v -p -n1 --long
2214
2037
2215
2038
``bzr tip`` will then show the latest revision while ``bzr top``
2216
2039
will show the last 10 mainline revisions. To see the details of a
2217
2040
particular revision X, ``bzr show -rX``.
2218
2041
2219
If you are interested in looking deeper into a particular merge X,
2220
use ``bzr log -n0 -rX``.
2042
As many GUI tools and Web interfaces do, you may prefer viewing
2043
history collapsed initially. If you are interested in looking deeper
2044
into a particular merge X, use ``bzr log -n0 -rX``. If you like
2045
working this way, you may wish to either:
2046
2047
* change your default log format to short (or line)
2048
* add this alias: log = log -n1
2221
2049
2222
2050
``bzr log -v`` on a branch with lots of history is currently
2223
2051
very slow. A fix for this issue is currently under development.
2231
2059
2232
2060
When exploring non-mainline history on large projects with deep
2233
2061
history, the performance of log can be greatly improved by installing
2234
the historycache plugin. This plugin buffers historical information
2062
the revnocache plugin. This plugin buffers historical information
2235
2063
trading disk space for faster speed.
2236
2064
"""
2237
takes_args = ['file*']
2065
takes_args = ['location?']
2238
2066
_see_also = ['log-formats', 'revisionspec']
2239
2067
takes_options = [
2240
2068
Option('forward',
2250
2078
help='Show just the specified revision.'
2251
2079
' See also "help revisionspec".'),
2252
2080
'log-format',
2253
RegistryOption('authors',
2254
'What names to list as authors - first, all or committer.',
2255
title='Authors',
2256
lazy_registry=('bzrlib.log', 'author_list_registry'),
2257
),
2258
2081
Option('levels',
2259
2082
short_name='n',
2260
2083
help='Number of levels to display - 0 for all, 1 for flat.',
2273
2096
Option('show-diff',
2274
2097
short_name='p',
2275
2098
help='Show changes made in each revision as a patch.'),
2276
Option('include-merges',
2277
help='Show merged revisions like --levels 0 does.'),
2278
Option('exclude-common-ancestry',
2279
help='Display only the revisions that are not part'
2280
' of both ancestries (require -rX..Y)'
2281
)
2282
2099
]
2283
2100
encoding_type = 'replace'
2284
2101
2285
2102
@display_command
2286
def run(self, file_list=None, timezone='original',
2103
def run(self, location=None, timezone='original',
2287
2104
verbose=False,
2288
2105
show_ids=False,
2289
2106
forward=False,
2293
2110
levels=None,
2294
2111
message=None,
2295
2112
limit=None,
2296
show_diff=False,
2297
include_merges=False,
2298
authors=None,
2299
exclude_common_ancestry=False,
2300
):
2301
from bzrlib.log import (
2302
Logger,
2303
make_log_request_dict,
2304
_get_info_for_log_files,
2305
)
2113
show_diff=False):
2114
from bzrlib.log import show_log, _get_fileid_to_log
2306
2115
direction = (forward and 'forward') or 'reverse'
2307
if (exclude_common_ancestry
2308
and (revision is None or len(revision) != 2)):
2309
raise errors.BzrCommandError(
2310
'--exclude-common-ancestry requires -r with two revisions')
2311
if include_merges:
2312
if levels is None:
2313
levels = 0
2314
else:
2315
raise errors.BzrCommandError(
2316
'--levels and --include-merges are mutually exclusive')
2317
2116
2318
2117
if change is not None:
2319
2118
if len(change) > 1:
2324
2123
else:
2325
2124
revision = change
2326
2125
2327
file_ids = []
2328
filter_by_dir = False
2329
if file_list:
2330
# find the file ids to log and check for directory filtering
2331
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2332
revision, file_list, self.add_cleanup)
2333
for relpath, file_id, kind in file_info_list:
2126
# log everything
2127
file_id = None
2128
if location:
2129
# find the file id to log:
2130
2131
tree, b, fp = bzrdir.BzrDir.open_containing_tree_or_branch(
2132
location)
2133
if fp != '':
2134
file_id = _get_fileid_to_log(revision, tree, b, fp)
2334
2135
if file_id is None:
2335
2136
raise errors.BzrCommandError(
2336
2137
"Path unknown at end or start of revision range: %s" %
2337
relpath)
2338
# If the relpath is the top of the tree, we log everything
2339
if relpath == '':
2340
file_ids = []
2341
break
2342
else:
2343
file_ids.append(file_id)
2344
filter_by_dir = filter_by_dir or (
2345
kind in ['directory', 'tree-reference'])
2138
location)
2346
2139
else:
2347
# log everything
2140
# local dir only
2348
2141
# FIXME ? log the current subdir only RBC 20060203
2349
2142
if revision is not None \
2350
2143
and len(revision) > 0 and revision[0].get_branch():
2353
2146
location = '.'
2354
2147
dir, relpath = bzrdir.BzrDir.open_containing(location)
2355
2148
b = dir.open_branch()
2356
self.add_cleanup(b.lock_read().unlock)
2149
2150
b.lock_read()
2151
try:
2357
2152
rev1, rev2 = _get_revision_range(revision, b, self.name())
2358
2359
# Decide on the type of delta & diff filtering to use
2360
# TODO: add an --all-files option to make this configurable & consistent
2361
if not verbose:
2362
delta_type = None
2363
else:
2364
delta_type = 'full'
2365
if not show_diff:
2366
diff_type = None
2367
elif file_ids:
2368
diff_type = 'partial'
2369
else:
2370
diff_type = 'full'
2371
2372
# Build the log formatter
2373
if log_format is None:
2374
log_format = log.log_formatter_registry.get_default(b)
2375
# Make a non-encoding output to include the diffs - bug 328007
2376
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2377
lf = log_format(show_ids=show_ids, to_file=self.outf,
2378
to_exact_file=unencoded_output,
2379
show_timezone=timezone,
2380
delta_format=get_verbosity_level(),
2381
levels=levels,
2382
show_advice=levels is None,
2383
author_list_handler=authors)
2384
2385
# Choose the algorithm for doing the logging. It's annoying
2386
# having multiple code paths like this but necessary until
2387
# the underlying repository format is faster at generating
2388
# deltas or can provide everything we need from the indices.
2389
# The default algorithm - match-using-deltas - works for
2390
# multiple files and directories and is faster for small
2391
# amounts of history (200 revisions say). However, it's too
2392
# slow for logging a single file in a repository with deep
2393
# history, i.e. > 10K revisions. In the spirit of "do no
2394
# evil when adding features", we continue to use the
2395
# original algorithm - per-file-graph - for the "single
2396
# file that isn't a directory without showing a delta" case.
2397
partial_history = revision and b.repository._format.supports_chks
2398
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2399
or delta_type or partial_history)
2400
2401
# Build the LogRequest and execute it
2402
if len(file_ids) == 0:
2403
file_ids = None
2404
rqst = make_log_request_dict(
2405
direction=direction, specific_fileids=file_ids,
2406
start_revision=rev1, end_revision=rev2, limit=limit,
2407
message_search=message, delta_type=delta_type,
2408
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2409
exclude_common_ancestry=exclude_common_ancestry,
2410
)
2411
Logger(b, rqst).show(lf)
2153
if log_format is None:
2154
log_format = log.log_formatter_registry.get_default(b)
2155
2156
lf = log_format(show_ids=show_ids, to_file=self.outf,
2157
show_timezone=timezone,
2158
delta_format=get_verbosity_level(),
2159
levels=levels)
2160
2161
show_log(b,
2162
lf,
2163
file_id,
2164
verbose=verbose,
2165
direction=direction,
2166
start_revision=rev1,
2167
end_revision=rev2,
2168
search=message,
2169
limit=limit,
2170
show_diff=show_diff)
2171
finally:
2172
b.unlock()
2412
2173
2413
2174
2414
2175
def _get_revision_range(revisionspec_list, branch, command_name):
2415
2176
"""Take the input of a revision option and turn it into a revision range.
2416
2177
2417
2178
It returns RevisionInfo objects which can be used to obtain the rev_id's
2418
of the desired revisions. It does some user input validations.
2179
of the desired revisons. It does some user input validations.
2419
2180
"""
2420
2181
if revisionspec_list is None:
2421
2182
rev1 = None
2432
2193
raise errors.BzrCommandError(
2433
2194
"bzr %s doesn't accept two revisions in different"
2434
2195
" branches." % command_name)
2435
if start_spec.spec is None:
2436
# Avoid loading all the history.
2437
rev1 = RevisionInfo(branch, None, None)
2438
else:
2439
rev1 = start_spec.in_history(branch)
2196
rev1 = start_spec.in_history(branch)
2440
2197
# Avoid loading all of history when we know a missing
2441
2198
# end of range means the last revision ...
2442
2199
if end_spec.spec is None:
2471
2228
2472
2229
2473
2230
class cmd_touching_revisions(Command):
2474
__doc__ = """Return revision-ids which affected a particular file.
2231
"""Return revision-ids which affected a particular file.
2475
2232
2476
2233
A more user-friendly interface is "bzr log FILE".
2477
2234
"""
2482
2239
@display_command
2483
2240
def run(self, filename):
2484
2241
tree, relpath = WorkingTree.open_containing(filename)
2242
b = tree.branch
2485
2243
file_id = tree.path2id(relpath)
2486
b = tree.branch
2487
self.add_cleanup(b.lock_read().unlock)
2488
touching_revs = log.find_touching_revisions(b, file_id)
2489
for revno, revision_id, what in touching_revs:
2244
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
2490
2245
self.outf.write("%6d %s\n" % (revno, what))
2491
2246
2492
2247
2493
2248
class cmd_ls(Command):
2494
__doc__ = """List files in a tree.
2249
"""List files in a tree.
2495
2250
"""
2496
2251
2497
2252
_see_also = ['status', 'cat']
2498
2253
takes_args = ['path?']
2254
# TODO: Take a revision or remote path and list that tree instead.
2499
2255
takes_options = [
2500
2256
'verbose',
2501
2257
'revision',
2502
Option('recursive', short_name='R',
2503
help='Recurse into subdirectories.'),
2258
Option('non-recursive',
2259
help='Don\'t recurse into subdirectories.'),
2504
2260
Option('from-root',
2505
2261
help='Print paths relative to the root of the branch.'),
2506
Option('unknown', short_name='u',
2507
help='Print unknown files.'),
2262
Option('unknown', help='Print unknown files.'),
2508
2263
Option('versioned', help='Print versioned files.',
2509
2264
short_name='V'),
2510
Option('ignored', short_name='i',
2511
help='Print ignored files.'),
2512
Option('kind', short_name='k',
2265
Option('ignored', help='Print ignored files.'),
2266
Option('null',
2267
help='Write an ascii NUL (\\0) separator '
2268
'between files rather than a newline.'),
2269
Option('kind',
2513
2270
help='List entries of a particular kind: file, directory, symlink.',
2514
2271
type=unicode),
2515
'null',
2516
2272
'show-ids',
2517
'directory',
2518
2273
]
2519
2274
@display_command
2520
2275
def run(self, revision=None, verbose=False,
2521
recursive=False, from_root=False,
2276
non_recursive=False, from_root=False,
2522
2277
unknown=False, versioned=False, ignored=False,
2523
null=False, kind=None, show_ids=False, path=None, directory=None):
2278
null=False, kind=None, show_ids=False, path=None):
2524
2279
2525
2280
if kind and kind not in ('file', 'directory', 'symlink'):
2526
2281
raise errors.BzrCommandError('invalid kind specified')
2533
2288
2534
2289
if path is None:
2535
2290
fs_path = '.'
2291
prefix = ''
2536
2292
else:
2537
2293
if from_root:
2538
2294
raise errors.BzrCommandError('cannot specify both --from-root'
2539
2295
' and PATH')
2540
2296
fs_path = path
2541
tree, branch, relpath = \
2542
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2543
2544
# Calculate the prefix to use
2545
prefix = None
2297
prefix = path
2298
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2299
fs_path)
2546
2300
if from_root:
2547
if relpath:
2548
prefix = relpath + '/'
2549
elif fs_path != '.' and not fs_path.endswith('/'):
2550
prefix = fs_path + '/'
2551
2301
relpath = u''
2302
elif relpath:
2303
relpath += '/'
2552
2304
if revision is not None or tree is None:
2553
2305
tree = _get_one_revision_tree('ls', revision, branch=branch)
2554
2306
2558
2310
if view_files:
2559
2311
apply_view = True
2560
2312
view_str = views.view_display_str(view_files)
2561
note("Ignoring files outside view. View is %s" % view_str)
2562
2563
self.add_cleanup(tree.lock_read().unlock)
2564
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2565
from_dir=relpath, recursive=recursive):
2566
# Apply additional masking
2567
if not all and not selection[fc]:
2568
continue
2569
if kind is not None and fkind != kind:
2570
continue
2571
if apply_view:
2572
try:
2573
if relpath:
2574
fullpath = osutils.pathjoin(relpath, fp)
2575
else:
2576
fullpath = fp
2577
views.check_path_in_view(tree, fullpath)
2578
except errors.FileOutsideView:
2579
continue
2580
2581
# Output the entry
2582
if prefix:
2583
fp = osutils.pathjoin(prefix, fp)
2584
kindch = entry.kind_character()
2585
outstring = fp + kindch
2586
ui.ui_factory.clear_term()
2587
if verbose:
2588
outstring = '%-8s %s' % (fc, outstring)
2589
if show_ids and fid is not None:
2590
outstring = "%-50s %s" % (outstring, fid)
2591
self.outf.write(outstring + '\n')
2592
elif null:
2593
self.outf.write(fp + '\0')
2594
if show_ids:
2595
if fid is not None:
2596
self.outf.write(fid)
2597
self.outf.write('\0')
2598
self.outf.flush()
2599
else:
2600
if show_ids:
2601
if fid is not None:
2602
my_id = fid
2603
else:
2604
my_id = ''
2605
self.outf.write('%-50s %s\n' % (outstring, my_id))
2606
else:
2607
self.outf.write(outstring + '\n')
2313
note("ignoring files outside view: %s" % view_str)
2314
2315
tree.lock_read()
2316
try:
2317
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False):
2318
if fp.startswith(relpath):
2319
fp = osutils.pathjoin(prefix, fp[len(relpath):])
2320
if non_recursive and '/' in fp:
2321
continue
2322
if not all and not selection[fc]:
2323
continue
2324
if kind is not None and fkind != kind:
2325
continue
2326
if apply_view:
2327
try:
2328
views.check_path_in_view(tree, fp)
2329
except errors.FileOutsideView:
2330
continue
2331
kindch = entry.kind_character()
2332
outstring = fp + kindch
2333
if verbose:
2334
outstring = '%-8s %s' % (fc, outstring)
2335
if show_ids and fid is not None:
2336
outstring = "%-50s %s" % (outstring, fid)
2337
self.outf.write(outstring + '\n')
2338
elif null:
2339
self.outf.write(fp + '\0')
2340
if show_ids:
2341
if fid is not None:
2342
self.outf.write(fid)
2343
self.outf.write('\0')
2344
self.outf.flush()
2345
else:
2346
if fid is not None:
2347
my_id = fid
2348
else:
2349
my_id = ''
2350
if show_ids:
2351
self.outf.write('%-50s %s\n' % (outstring, my_id))
2352
else:
2353
self.outf.write(outstring + '\n')
2354
finally:
2355
tree.unlock()
2608
2356
2609
2357
2610
2358
class cmd_unknowns(Command):
2611
__doc__ = """List unknown files.
2359
"""List unknown files.
2612
2360
"""
2613
2361
2614
2362
hidden = True
2615
2363
_see_also = ['ls']
2616
takes_options = ['directory']
2617
2364
2618
2365
@display_command
2619
def run(self, directory=u'.'):
2620
for f in WorkingTree.open_containing(directory)[0].unknowns():
2366
def run(self):
2367
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2621
2368
self.outf.write(osutils.quotefn(f) + '\n')
2622
2369
2623
2370
2624
2371
class cmd_ignore(Command):
2625
__doc__ = """Ignore specified files or patterns.
2372
"""Ignore specified files or patterns.
2626
2373
2627
2374
See ``bzr help patterns`` for details on the syntax of patterns.
2628
2375
2629
If a .bzrignore file does not exist, the ignore command
2630
will create one and add the specified files or patterns to the newly
2631
created file. The ignore command will also automatically add the
2632
.bzrignore file to be versioned. Creating a .bzrignore file without
2633
the use of the ignore command will require an explicit add command.
2634
2635
2376
To remove patterns from the ignore list, edit the .bzrignore file.
2636
2377
After adding, editing or deleting that file either indirectly by
2637
2378
using this command or directly by using an editor, be sure to commit
2638
2379
it.
2639
2640
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2641
the global ignore file can be found in the application data directory as
2642
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2643
Global ignores are not touched by this command. The global ignore file
2644
can be edited directly using an editor.
2645
2646
Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
precedence over regular ignores. Such exceptions are used to specify
2648
files that should be versioned which would otherwise be ignored.
2649
2650
Patterns prefixed with '!!' act as regular ignore patterns, but have
2651
precedence over the '!' exception patterns.
2652
2380
2653
2381
Note: ignore patterns containing shell wildcards must be quoted from
2654
2382
the shell on Unix.
2658
2386
2659
2387
bzr ignore ./Makefile
2660
2388
2661
Ignore .class files in all directories...::
2389
Ignore class files in all directories::
2662
2390
2663
2391
bzr ignore "*.class"
2664
2392
2665
...but do not ignore "special.class"::
2666
2667
bzr ignore "!special.class"
2668
2669
2393
Ignore .o files under the lib directory::
2670
2394
2671
2395
bzr ignore "lib/**/*.o"
2677
2401
Ignore everything but the "debian" toplevel directory::
2678
2402
2679
2403
bzr ignore "RE:(?!debian/).*"
2680
2681
Ignore everything except the "local" toplevel directory,
2682
but always ignore "*~" autosave files, even under local/::
2683
2684
bzr ignore "*"
2685
bzr ignore "!./local"
2686
bzr ignore "!!*~"
2687
2404
"""
2688
2405
2689
2406
_see_also = ['status', 'ignored', 'patterns']
2690
2407
takes_args = ['name_pattern*']
2691
takes_options = ['directory',
2692
Option('default-rules',
2693
help='Display the default ignore rules that bzr uses.')
2408
takes_options = [
2409
Option('old-default-rules',
2410
help='Write out the ignore rules bzr < 0.9 always used.')
2694
2411
]
2695
2412
2696
def run(self, name_pattern_list=None, default_rules=None,
2697
directory=u'.'):
2413
def run(self, name_pattern_list=None, old_default_rules=None):
2698
2414
from bzrlib import ignores
2699
if default_rules is not None:
2700
# dump the default rules and exit
2701
for pattern in ignores.USER_DEFAULTS:
2702
self.outf.write("%s\n" % pattern)
2415
if old_default_rules is not None:
2416
# dump the rules and exit
2417
for pattern in ignores.OLD_DEFAULTS:
2418
print pattern
2703
2419
return
2704
2420
if not name_pattern_list:
2705
2421
raise errors.BzrCommandError("ignore requires at least one "
2706
"NAME_PATTERN or --default-rules.")
2422
"NAME_PATTERN or --old-default-rules")
2707
2423
name_pattern_list = [globbing.normalize_pattern(p)
2708
2424
for p in name_pattern_list]
2709
2425
for name_pattern in name_pattern_list:
2711
2427
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2712
2428
raise errors.BzrCommandError(
2713
2429
"NAME_PATTERN should not be an absolute path")
2714
tree, relpath = WorkingTree.open_containing(directory)
2430
tree, relpath = WorkingTree.open_containing(u'.')
2715
2431
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2716
2432
ignored = globbing.Globster(name_pattern_list)
2717
2433
matches = []
2721
2437
if id is not None:
2722
2438
filename = entry[0]
2723
2439
if ignored.match(filename):
2724
matches.append(filename)
2440
matches.append(filename.encode('utf-8'))
2725
2441
tree.unlock()
2726
2442
if len(matches) > 0:
2727
self.outf.write("Warning: the following files are version controlled and"
2728
" match your ignore pattern:\n%s"
2729
"\nThese files will continue to be version controlled"
2730
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2443
print "Warning: the following files are version controlled and" \
2444
" match your ignore pattern:\n%s" \
2445
"\nThese files will continue to be version controlled" \
2446
" unless you 'bzr remove' them." % ("\n".join(matches),)
2731
2447
2732
2448
2733
2449
class cmd_ignored(Command):
2734
__doc__ = """List ignored files and the patterns that matched them.
2450
"""List ignored files and the patterns that matched them.
2735
2451
2736
2452
List all the ignored files and the ignore pattern that caused the file to
2737
2453
be ignored.
2743
2459
2744
2460
encoding_type = 'replace'
2745
2461
_see_also = ['ignore', 'ls']
2746
takes_options = ['directory']
2747
2462
2748
2463
@display_command
2749
def run(self, directory=u'.'):
2750
tree = WorkingTree.open_containing(directory)[0]
2751
self.add_cleanup(tree.lock_read().unlock)
2752
for path, file_class, kind, file_id, entry in tree.list_files():
2753
if file_class != 'I':
2754
continue
2755
## XXX: Slightly inefficient since this was already calculated
2756
pat = tree.is_ignored(path)
2757
self.outf.write('%-50s %s\n' % (path, pat))
2464
def run(self):
2465
tree = WorkingTree.open_containing(u'.')[0]
2466
tree.lock_read()
2467
try:
2468
for path, file_class, kind, file_id, entry in tree.list_files():
2469
if file_class != 'I':
2470
continue
2471
## XXX: Slightly inefficient since this was already calculated
2472
pat = tree.is_ignored(path)
2473
self.outf.write('%-50s %s\n' % (path, pat))
2474
finally:
2475
tree.unlock()
2758
2476
2759
2477
2760
2478
class cmd_lookup_revision(Command):
2761
__doc__ = """Lookup the revision-id from a revision-number
2479
"""Lookup the revision-id from a revision-number
2762
2480
2763
2481
:Examples:
2764
2482
bzr lookup-revision 33
2765
2483
"""
2766
2484
hidden = True
2767
2485
takes_args = ['revno']
2768
takes_options = ['directory']
2769
2486
2770
2487
@display_command
2771
def run(self, revno, directory=u'.'):
2488
def run(self, revno):
2772
2489
try:
2773
2490
revno = int(revno)
2774
2491
except ValueError:
2775
raise errors.BzrCommandError("not a valid revision-number: %r"
2776
% revno)
2777
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2778
self.outf.write("%s\n" % revid)
2492
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2493
2494
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2779
2495
2780
2496
2781
2497
class cmd_export(Command):
2782
__doc__ = """Export current or past revision to a destination directory or archive.
2498
"""Export current or past revision to a destination directory or archive.
2783
2499
2784
2500
If no revision is specified this exports the last committed revision.
2785
2501
2807
2523
================= =========================
2808
2524
"""
2809
2525
takes_args = ['dest', 'branch_or_subdir?']
2810
takes_options = ['directory',
2526
takes_options = [
2811
2527
Option('format',
2812
2528
help="Type of file to export to.",
2813
2529
type=unicode),
2817
2533
Option('root',
2818
2534
type=str,
2819
2535
help="Name of the root directory inside the exported file."),
2820
Option('per-file-timestamps',
2821
help='Set modification time of files to that of the last '
2822
'revision in which it was changed.'),
2823
2536
]
2824
2537
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2825
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2538
root=None, filters=False):
2826
2539
from bzrlib.export import export
2827
2540
2828
2541
if branch_or_subdir is None:
2829
tree = WorkingTree.open_containing(directory)[0]
2542
tree = WorkingTree.open_containing(u'.')[0]
2830
2543
b = tree.branch
2831
2544
subdir = None
2832
2545
else:
2835
2548
2836
2549
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2837
2550
try:
2838
export(rev_tree, dest, format, root, subdir, filtered=filters,
2839
per_file_timestamps=per_file_timestamps)
2551
export(rev_tree, dest, format, root, subdir, filtered=filters)
2840
2552
except errors.NoSuchExportFormat, e:
2841
2553
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2842
2554
2843
2555
2844
2556
class cmd_cat(Command):
2845
__doc__ = """Write the contents of a file as of a given revision to standard output.
2557
"""Write the contents of a file as of a given revision to standard output.
2846
2558
2847
2559
If no revision is nominated, the last revision is used.
2848
2560
2851
2563
"""
2852
2564
2853
2565
_see_also = ['ls']
2854
takes_options = ['directory',
2566
takes_options = [
2855
2567
Option('name-from-revision', help='The path name in the old tree.'),
2856
2568
Option('filters', help='Apply content filters to display the '
2857
2569
'convenience form.'),
2862
2574
2863
2575
@display_command
2864
2576
def run(self, filename, revision=None, name_from_revision=False,
2865
filters=False, directory=None):
2577
filters=False):
2866
2578
if revision is not None and len(revision) != 1:
2867
2579
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2868
2580
" one revision specifier")
2869
2581
tree, branch, relpath = \
2870
_open_directory_or_containing_tree_or_branch(filename, directory)
2871
self.add_cleanup(branch.lock_read().unlock)
2872
return self._run(tree, branch, relpath, filename, revision,
2873
name_from_revision, filters)
2582
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2583
branch.lock_read()
2584
try:
2585
return self._run(tree, branch, relpath, filename, revision,
2586
name_from_revision, filters)
2587
finally:
2588
branch.unlock()
2874
2589
2875
2590
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2876
2591
filtered):
2877
2592
if tree is None:
2878
2593
tree = b.basis_tree()
2879
2594
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2880
self.add_cleanup(rev_tree.lock_read().unlock)
2881
2595
2882
2596
old_file_id = rev_tree.path2id(relpath)
2883
2597
2918
2632
chunks = content.splitlines(True)
2919
2633
content = filtered_output_bytes(chunks, filters,
2920
2634
ContentFilterContext(relpath, rev_tree))
2921
self.cleanup_now()
2922
2635
self.outf.writelines(content)
2923
2636
else:
2924
self.cleanup_now()
2925
2637
self.outf.write(content)
2926
2638
2927
2639
2928
2640
class cmd_local_time_offset(Command):
2929
__doc__ = """Show the offset in seconds from GMT to local time."""
2641
"""Show the offset in seconds from GMT to local time."""
2930
2642
hidden = True
2931
2643
@display_command
2932
2644
def run(self):
2933
self.outf.write("%s\n" % osutils.local_time_offset())
2645
print osutils.local_time_offset()
2934
2646
2935
2647
2936
2648
2937
2649
class cmd_commit(Command):
2938
__doc__ = """Commit changes into a new revision.
2939
2940
An explanatory message needs to be given for each commit. This is
2941
often done by using the --message option (getting the message from the
2942
command line) or by using the --file option (getting the message from
2943
a file). If neither of these options is given, an editor is opened for
2944
the user to enter the message. To see the changed files in the
2945
boilerplate text loaded into the editor, use the --show-diff option.
2946
2947
By default, the entire tree is committed and the person doing the
2948
commit is assumed to be the author. These defaults can be overridden
2949
as explained below.
2950
2951
:Selective commits:
2952
2953
If selected files are specified, only changes to those files are
2954
committed. If a directory is specified then the directory and
2955
everything within it is committed.
2956
2957
When excludes are given, they take precedence over selected files.
2958
For example, to commit only changes within foo, but not changes
2959
within foo/bar::
2960
2961
bzr commit foo -x foo/bar
2962
2963
A selective commit after a merge is not yet supported.
2964
2965
:Custom authors:
2966
2967
If the author of the change is not the same person as the committer,
2968
you can specify the author's name using the --author option. The
2969
name should be in the same format as a committer-id, e.g.
2970
"John Doe <jdoe@example.com>". If there is more than one author of
2971
the change you can specify the option multiple times, once for each
2972
author.
2973
2974
:Checks:
2975
2976
A common mistake is to forget to add a new file or directory before
2977
running the commit command. The --strict option checks for unknown
2978
files and aborts the commit if any are found. More advanced pre-commit
2979
checks can be implemented by defining hooks. See ``bzr help hooks``
2980
for details.
2981
2982
:Things to note:
2983
2984
If you accidentially commit the wrong changes or make a spelling
2985
mistake in the commit message say, you can use the uncommit command
2986
to undo it. See ``bzr help uncommit`` for details.
2987
2988
Hooks can also be configured to run after a commit. This allows you
2989
to trigger updates to external systems like bug trackers. The --fixes
2990
option can be used to record the association between a revision and
2991
one or more bugs. See ``bzr help bugs`` for details.
2992
2993
A selective commit may fail in some cases where the committed
2994
tree would be invalid. Consider::
2995
2996
bzr init foo
2997
mkdir foo/bar
2998
bzr add foo/bar
2999
bzr commit foo -m "committing foo"
3000
bzr mv foo/bar foo/baz
3001
mkdir foo/bar
3002
bzr add foo/bar
3003
bzr commit foo/bar -m "committing bar but not baz"
3004
3005
In the example above, the last commit will fail by design. This gives
3006
the user the opportunity to decide whether they want to commit the
3007
rename at the same time, separately first, or not at all. (As a general
3008
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2650
"""Commit changes into a new revision.
2651
2652
If no arguments are given, the entire tree is committed.
2653
2654
If selected files are specified, only changes to those files are
2655
committed. If a directory is specified then the directory and everything
2656
within it is committed.
2657
2658
When excludes are given, they take precedence over selected files.
2659
For example, too commit only changes within foo, but not changes within
2660
foo/bar::
2661
2662
bzr commit foo -x foo/bar
2663
2664
If author of the change is not the same person as the committer, you can
2665
specify the author's name using the --author option. The name should be
2666
in the same format as a committer-id, e.g. "John Doe <jdoe@example.com>".
2667
If there is more than one author of the change you can specify the option
2668
multiple times, once for each author.
2669
2670
A selected-file commit may fail in some cases where the committed
2671
tree would be invalid. Consider::
2672
2673
bzr init foo
2674
mkdir foo/bar
2675
bzr add foo/bar
2676
bzr commit foo -m "committing foo"
2677
bzr mv foo/bar foo/baz
2678
mkdir foo/bar
2679
bzr add foo/bar
2680
bzr commit foo/bar -m "committing bar but not baz"
2681
2682
In the example above, the last commit will fail by design. This gives
2683
the user the opportunity to decide whether they want to commit the
2684
rename at the same time, separately first, or not at all. (As a general
2685
rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
2686
2687
Note: A selected-file commit after a merge is not yet supported.
3009
2688
"""
3010
2689
# TODO: Run hooks on tree to-be-committed, and after commit.
3011
2690
3016
2695
3017
2696
# XXX: verbose currently does nothing
3018
2697
3019
_see_also = ['add', 'bugs', 'hooks', 'uncommit']
2698
_see_also = ['bugs', 'uncommit']
3020
2699
takes_args = ['selected*']
3021
2700
takes_options = [
3022
2701
ListOption('exclude', type=str, short_name='x',
3034
2713
Option('strict',
3035
2714
help="Refuse to commit if there are unknown "
3036
2715
"files in the working tree."),
3037
Option('commit-time', type=str,
3038
help="Manually set a commit time using commit date "
3039
"format, e.g. '2009-10-10 08:00:00 +0100'."),
3040
2716
ListOption('fixes', type=str,
3041
2717
help="Mark a bug as being fixed by this revision "
3042
2718
"(see \"bzr help bugs\")."),
3049
2725
"the master branch until a normal commit "
3050
2726
"is performed."
3051
2727
),
3052
Option('show-diff', short_name='p',
3053
help='When no message is supplied, show the diff along'
3054
' with the status summary in the message editor.'),
2728
Option('show-diff',
2729
help='When no message is supplied, show the diff along'
2730
' with the status summary in the message editor.'),
3055
2731
]
3056
2732
aliases = ['ci', 'checkin']
3057
2733
3076
2752
3077
2753
def run(self, message=None, file=None, verbose=False, selected_list=None,
3078
2754
unchanged=False, strict=False, local=False, fixes=None,
3079
author=None, show_diff=False, exclude=None, commit_time=None):
2755
author=None, show_diff=False, exclude=None):
3080
2756
from bzrlib.errors import (
3081
2757
PointlessCommit,
3082
2758
ConflictsInTree,
3088
2764
make_commit_message_template_encoded
3089
2765
)
3090
2766
3091
commit_stamp = offset = None
3092
if commit_time is not None:
3093
try:
3094
commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3095
except ValueError, e:
3096
raise errors.BzrCommandError(
3097
"Could not parse --commit-time: " + str(e))
3098
3099
2767
# TODO: Need a blackbox test for invoking the external editor; may be
3100
2768
# slightly problematic to run this cross-platform.
3101
2769
3121
2789
if local and not tree.branch.get_bound_location():
3122
2790
raise errors.LocalRequiresBoundBranch()
3123
2791
3124
if message is not None:
3125
try:
3126
file_exists = osutils.lexists(message)
3127
except UnicodeError:
3128
# The commit message contains unicode characters that can't be
3129
# represented in the filesystem encoding, so that can't be a
3130
# file.
3131
file_exists = False
3132
if file_exists:
3133
warning_msg = (
3134
'The commit message is a file name: "%(f)s".\n'
3135
'(use --file "%(f)s" to take commit message from that file)'
3136
% { 'f': message })
3137
ui.ui_factory.show_warning(warning_msg)
3138
if '\r' in message:
3139
message = message.replace('\r\n', '\n')
3140
message = message.replace('\r', '\n')
3141
if file:
3142
raise errors.BzrCommandError(
3143
"please specify either --message or --file")
3144
3145
2792
def get_message(commit_obj):
3146
2793
"""Callback to get commit message"""
3147
if file:
3148
f = codecs.open(file, 'rt', osutils.get_user_encoding())
3149
try:
3150
my_message = f.read()
3151
finally:
3152
f.close()
3153
elif message is not None:
3154
my_message = message
3155
else:
3156
# No message supplied: make one up.
3157
# text is the status of the tree
3158
text = make_commit_message_template_encoded(tree,
2794
my_message = message
2795
if my_message is None and not file:
2796
t = make_commit_message_template_encoded(tree,
3159
2797
selected_list, diff=show_diff,
3160
2798
output_encoding=osutils.get_user_encoding())
3161
# start_message is the template generated from hooks
3162
# XXX: Warning - looks like hooks return unicode,
3163
# make_commit_message_template_encoded returns user encoding.
3164
# We probably want to be using edit_commit_message instead to
3165
# avoid this.
3166
2799
start_message = generate_commit_message_template(commit_obj)
3167
my_message = edit_commit_message_encoded(text,
2800
my_message = edit_commit_message_encoded(t,
3168
2801
start_message=start_message)
3169
2802
if my_message is None:
3170
2803
raise errors.BzrCommandError("please specify a commit"
3171
2804
" message with either --message or --file")
2805
elif my_message and file:
2806
raise errors.BzrCommandError(
2807
"please specify either --message or --file")
2808
if file:
2809
my_message = codecs.open(file, 'rt',
2810
osutils.get_user_encoding()).read()
3172
2811
if my_message == "":
3173
2812
raise errors.BzrCommandError("empty commit message specified")
3174
2813
return my_message
3175
2814
3176
# The API permits a commit with a filter of [] to mean 'select nothing'
3177
# but the command line should not do that.
3178
if not selected_list:
3179
selected_list = None
3180
2815
try:
3181
2816
tree.commit(message_callback=get_message,
3182
2817
specific_files=selected_list,
3183
2818
allow_pointless=unchanged, strict=strict, local=local,
3184
2819
reporter=None, verbose=verbose, revprops=properties,
3185
authors=author, timestamp=commit_stamp,
3186
timezone=offset,
2820
authors=author,
3187
2821
exclude=safe_relpath_files(tree, exclude))
3188
2822
except PointlessCommit:
3189
raise errors.BzrCommandError("No changes to commit."
3190
" Use --unchanged to commit anyhow.")
2823
# FIXME: This should really happen before the file is read in;
2824
# perhaps prepare the commit; get the message; then actually commit
2825
raise errors.BzrCommandError("no changes to commit."
2826
" use --unchanged to commit anyhow")
3191
2827
except ConflictsInTree:
3192
2828
raise errors.BzrCommandError('Conflicts detected in working '
3193
2829
'tree. Use "bzr conflicts" to list, "bzr resolve FILE" to'
3196
2832
raise errors.BzrCommandError("Commit refused because there are"
3197
2833
" unknown files in the working tree.")
3198
2834
except errors.BoundBranchOutOfDate, e:
3199
e.extra_help = ("\n"
3200
'To commit to master branch, run update and then commit.\n'
3201
'You can also pass --local to commit to continue working '
3202
'disconnected.')
3203
raise
2835
raise errors.BzrCommandError(str(e) + "\n"
2836
'To commit to master branch, run update and then commit.\n'
2837
'You can also pass --local to commit to continue working '
2838
'disconnected.')
3204
2839
3205
2840
3206
2841
class cmd_check(Command):
3207
__doc__ = """Validate working tree structure, branch consistency and repository history.
2842
"""Validate working tree structure, branch consistency and repository history.
3208
2843
3209
2844
This command checks various invariants about branch and repository storage
3210
2845
to detect data corruption or bzr bugs.
3212
2847
The working tree and branch checks will only give output if a problem is
3213
2848
detected. The output fields of the repository check are:
3214
2849
3215
revisions
3216
This is just the number of revisions checked. It doesn't
3217
indicate a problem.
3218
3219
versionedfiles
3220
This is just the number of versionedfiles checked. It
3221
doesn't indicate a problem.
3222
3223
unreferenced ancestors
3224
Texts that are ancestors of other texts, but
3225
are not properly referenced by the revision ancestry. This is a
3226
subtle problem that Bazaar can work around.
3227
3228
unique file texts
3229
This is the total number of unique file contents
3230
seen in the checked revisions. It does not indicate a problem.
3231
3232
repeated file texts
3233
This is the total number of repeated texts seen
3234
in the checked revisions. Texts can be repeated when their file
3235
entries are modified, but the file contents are not. It does not
3236
indicate a problem.
2850
revisions: This is just the number of revisions checked. It doesn't
2851
indicate a problem.
2852
versionedfiles: This is just the number of versionedfiles checked. It
2853
doesn't indicate a problem.
2854
unreferenced ancestors: Texts that are ancestors of other texts, but
2855
are not properly referenced by the revision ancestry. This is a
2856
subtle problem that Bazaar can work around.
2857
unique file texts: This is the total number of unique file contents
2858
seen in the checked revisions. It does not indicate a problem.
2859
repeated file texts: This is the total number of repeated texts seen
2860
in the checked revisions. Texts can be repeated when their file
2861
entries are modified, but the file contents are not. It does not
2862
indicate a problem.
3237
2863
3238
2864
If no restrictions are specified, all Bazaar data that is found at the given
3239
2865
location will be checked.
3274
2900
3275
2901
3276
2902
class cmd_upgrade(Command):
3277
__doc__ = """Upgrade branch storage to current format.
2903
"""Upgrade branch storage to current format.
3278
2904
3279
2905
The check command or bzr developers may sometimes advise you to run
3280
2906
this command. When the default format has changed you may also be warned
3294
2920
3295
2921
def run(self, url='.', format=None):
3296
2922
from bzrlib.upgrade import upgrade
2923
if format is None:
2924
format = bzrdir.format_registry.make_bzrdir('default')
3297
2925
upgrade(url, format)
3298
2926
3299
2927
3300
2928
class cmd_whoami(Command):
3301
__doc__ = """Show or set bzr user id.
2929
"""Show or set bzr user id.
3302
2930
3303
2931
:Examples:
3304
2932
Show the email of the current user::
3348
2976
3349
2977
3350
2978
class cmd_nick(Command):
3351
__doc__ = """Print or set the branch nickname.
2979
"""Print or set the branch nickname.
3352
2980
3353
2981
If unset, the tree root directory name is used as the nickname.
3354
2982
To print the current nickname, execute with no argument.
3359
2987
3360
2988
_see_also = ['info']
3361
2989
takes_args = ['nickname?']
3362
takes_options = ['directory']
3363
def run(self, nickname=None, directory=u'.'):
3364
branch = Branch.open_containing(directory)[0]
2990
def run(self, nickname=None):
2991
branch = Branch.open_containing(u'.')[0]
3365
2992
if nickname is None:
3366
2993
self.printme(branch)
3367
2994
else:
3369
2996
3370
2997
@display_command
3371
2998
def printme(self, branch):
3372
self.outf.write('%s\n' % branch.nick)
2999
print branch.nick
3373
3000
3374
3001
3375
3002
class cmd_alias(Command):
3376
__doc__ = """Set/unset and display aliases.
3003
"""Set/unset and display aliases.
3377
3004
3378
3005
:Examples:
3379
3006
Show the current aliases::
3443
3070
3444
3071
3445
3072
class cmd_selftest(Command):
3446
__doc__ = """Run internal test suite.
3073
"""Run internal test suite.
3447
3074
3448
3075
If arguments are given, they are regular expressions that say which tests
3449
3076
should run. Tests matching any expression are run, and other tests are
3476
3103
Tests that need working space on disk use a common temporary directory,
3477
3104
typically inside $TMPDIR or /tmp.
3478
3105
3479
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3480
into a pdb postmortem session.
3481
3482
3106
:Examples:
3483
3107
Run only tests relating to 'ignore'::
3484
3108
3493
3117
def get_transport_type(typestring):
3494
3118
"""Parse and return a transport specifier."""
3495
3119
if typestring == "sftp":
3496
from bzrlib.tests import stub_sftp
3497
return stub_sftp.SFTPAbsoluteServer
3120
from bzrlib.transport.sftp import SFTPAbsoluteServer
3121
return SFTPAbsoluteServer
3498
3122
if typestring == "memory":
3499
from bzrlib.tests import test_server
3500
return memory.MemoryServer
3123
from bzrlib.transport.memory import MemoryServer
3124
return MemoryServer
3501
3125
if typestring == "fakenfs":
3502
from bzrlib.tests import test_server
3503
return test_server.FakeNFSServer
3126
from bzrlib.transport.fakenfs import FakeNFSServer
3127
return FakeNFSServer
3504
3128
msg = "No known transport type %s. Supported types are: sftp\n" %\
3505
3129
(typestring)
3506
3130
raise errors.BzrCommandError(msg)
3521
3145
Option('lsprof-timed',
3522
3146
help='Generate lsprof output for benchmarked'
3523
3147
' sections of code.'),
3524
Option('lsprof-tests',
3525
help='Generate lsprof output for each test.'),
3526
3148
Option('cache-dir', type=str,
3527
3149
help='Cache intermediate benchmark output in this '
3528
3150
'directory.'),
3532
3154
),
3533
3155
Option('list-only',
3534
3156
help='List the tests instead of running them.'),
3535
RegistryOption('parallel',
3536
help="Run the test suite in parallel.",
3537
lazy_registry=('bzrlib.tests', 'parallel_registry'),
3538
value_switches=False,
3539
),
3540
3157
Option('randomize', type=str, argname="SEED",
3541
3158
help='Randomize the order of tests using the given'
3542
3159
' seed or "now" for the current time.'),
3568
3185
lsprof_timed=None, cache_dir=None,
3569
3186
first=False, list_only=False,
3570
3187
randomize=None, exclude=None, strict=False,
3571
load_list=None, debugflag=None, starting_with=None, subunit=False,
3572
parallel=None, lsprof_tests=False):
3188
load_list=None, debugflag=None, starting_with=None, subunit=False):
3573
3189
from bzrlib.tests import selftest
3574
3190
import bzrlib.benchmarks as benchmarks
3575
3191
from bzrlib.benchmarks import tree_creator
3579
3195
3580
3196
if cache_dir is not None:
3581
3197
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3198
if not list_only:
3199
print 'testing: %s' % (osutils.realpath(sys.argv[0]),)
3200
print ' %s (%s python%s)' % (
3201
bzrlib.__path__[0],
3202
bzrlib.version_string,
3203
bzrlib._format_version_tuple(sys.version_info),
3204
)
3205
print
3582
3206
if testspecs_list is not None:
3583
3207
pattern = '|'.join(testspecs_list)
3584
3208
else:
3590
3214
raise errors.BzrCommandError("subunit not available. subunit "
3591
3215
"needs to be installed to use --subunit.")
3592
3216
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3593
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3594
# stdout, which would corrupt the subunit stream.
3595
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3596
# following code can be deleted when it's sufficiently deployed
3597
# -- vila/mgz 20100514
3598
if (sys.platform == "win32"
3599
and getattr(sys.stdout, 'fileno', None) is not None):
3600
import msvcrt
3601
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3602
if parallel:
3603
self.additional_selftest_args.setdefault(
3604
'suite_decorators', []).append(parallel)
3605
3217
if benchmark:
3606
3218
test_suite_factory = benchmarks.test_suite
3607
3219
# Unless user explicitly asks for quiet, be verbose in benchmarks
3608
3220
verbose = not is_quiet()
3609
3221
# TODO: should possibly lock the history file...
3610
3222
benchfile = open(".perf_history", "at", buffering=1)
3611
self.add_cleanup(benchfile.close)
3612
3223
else:
3613
3224
test_suite_factory = None
3614
3225
benchfile = None
3615
selftest_kwargs = {"verbose": verbose,
3616
"pattern": pattern,
3617
"stop_on_failure": one,
3618
"transport": transport,
3619
"test_suite_factory": test_suite_factory,
3620
"lsprof_timed": lsprof_timed,
3621
"lsprof_tests": lsprof_tests,
3622
"bench_history": benchfile,
3623
"matching_tests_first": first,
3624
"list_only": list_only,
3625
"random_seed": randomize,
3626
"exclude_pattern": exclude,
3627
"strict": strict,
3628
"load_list": load_list,
3629
"debug_flags": debugflag,
3630
"starting_with": starting_with
3631
}
3632
selftest_kwargs.update(self.additional_selftest_args)
3633
result = selftest(**selftest_kwargs)
3226
try:
3227
selftest_kwargs = {"verbose": verbose,
3228
"pattern": pattern,
3229
"stop_on_failure": one,
3230
"transport": transport,
3231
"test_suite_factory": test_suite_factory,
3232
"lsprof_timed": lsprof_timed,
3233
"bench_history": benchfile,
3234
"matching_tests_first": first,
3235
"list_only": list_only,
3236
"random_seed": randomize,
3237
"exclude_pattern": exclude,
3238
"strict": strict,
3239
"load_list": load_list,
3240
"debug_flags": debugflag,
3241
"starting_with": starting_with
3242
}
3243
selftest_kwargs.update(self.additional_selftest_args)
3244
result = selftest(**selftest_kwargs)
3245
finally:
3246
if benchfile is not None:
3247
benchfile.close()
3248
if result:
3249
note('tests passed')
3250
else:
3251
note('tests failed')
3634
3252
return int(not result)
3635
3253
3636
3254
3637
3255
class cmd_version(Command):
3638
__doc__ = """Show version of bzr."""
3256
"""Show version of bzr."""
3639
3257
3640
3258
encoding_type = 'replace'
3641
3259
takes_options = [
3652
3270
3653
3271
3654
3272
class cmd_rocks(Command):
3655
__doc__ = """Statement of optimism."""
3273
"""Statement of optimism."""
3656
3274
3657
3275
hidden = True
3658
3276
3659
3277
@display_command
3660
3278
def run(self):
3661
self.outf.write("It sure does!\n")
3279
print "It sure does!"
3662
3280
3663
3281
3664
3282
class cmd_find_merge_base(Command):
3665
__doc__ = """Find and print a base revision for merging two branches."""
3283
"""Find and print a base revision for merging two branches."""
3666
3284
# TODO: Options to specify revisions on either side, as if
3667
3285
# merging only part of the history.
3668
3286
takes_args = ['branch', 'other']
3674
3292
3675
3293
branch1 = Branch.open_containing(branch)[0]
3676
3294
branch2 = Branch.open_containing(other)[0]
3677
self.add_cleanup(branch1.lock_read().unlock)
3678
self.add_cleanup(branch2.lock_read().unlock)
3679
last1 = ensure_null(branch1.last_revision())
3680
last2 = ensure_null(branch2.last_revision())
3681
3682
graph = branch1.repository.get_graph(branch2.repository)
3683
base_rev_id = graph.find_unique_lca(last1, last2)
3684
3685
self.outf.write('merge base is revision %s\n' % base_rev_id)
3295
branch1.lock_read()
3296
try:
3297
branch2.lock_read()
3298
try:
3299
last1 = ensure_null(branch1.last_revision())
3300
last2 = ensure_null(branch2.last_revision())
3301
3302
graph = branch1.repository.get_graph(branch2.repository)
3303
base_rev_id = graph.find_unique_lca(last1, last2)
3304
3305
print 'merge base is revision %s' % base_rev_id
3306
finally:
3307
branch2.unlock()
3308
finally:
3309
branch1.unlock()
3686
3310
3687
3311
3688
3312
class cmd_merge(Command):
3689
__doc__ = """Perform a three-way merge.
3313
"""Perform a three-way merge.
3690
3314
3691
3315
The source of the merge can be specified either in the form of a branch,
3692
3316
or in the form of a path to a file containing a merge directive generated
3721
3345
committed to record the result of the merge.
3722
3346
3723
3347
merge refuses to run if there are any uncommitted changes, unless
3724
--force is given. The --force option can also be used to create a
3725
merge revision which has more than two parents.
3726
3727
If one would like to merge changes from the working tree of the other
3728
branch without merging any committed revisions, the --uncommitted option
3729
can be given.
3730
3731
To select only some changes to merge, use "merge -i", which will prompt
3732
you to apply each diff hunk and file change, similar to "shelve".
3348
--force is given.
3733
3349
3734
3350
:Examples:
3735
3351
To merge the latest revision from bzr.dev::
3744
3360
3745
3361
bzr merge -r 81..82 ../bzr.dev
3746
3362
3747
To apply a merge directive contained in /tmp/merge::
3363
To apply a merge directive contained in in /tmp/merge:
3748
3364
3749
3365
bzr merge /tmp/merge
3750
3751
To create a merge revision with three parents from two branches
3752
feature1a and feature1b:
3753
3754
bzr merge ../feature1a
3755
bzr merge ../feature1b --force
3756
bzr commit -m 'revision with three parents'
3757
3366
"""
3758
3367
3759
3368
encoding_type = 'exact'
3775
3384
' completely merged into the source, pull from the'
3776
3385
' source rather than merging. When this happens,'
3777
3386
' you do not need to commit the result.'),
3778
custom_help('directory',
3387
Option('directory',
3779
3388
help='Branch to merge into, '
3780
'rather than the one containing the working directory.'),
3781
Option('preview', help='Instead of merging, show a diff of the'
3782
' merge.'),
3783
Option('interactive', help='Select changes interactively.',
3784
short_name='i')
3389
'rather than the one containing the working directory.',
3390
short_name='d',
3391
type=unicode,
3392
),
3393
Option('preview', help='Instead of merging, show a diff of the merge.')
3785
3394
]
3786
3395
3787
3396
def run(self, location=None, revision=None, force=False,
3789
3398
uncommitted=False, pull=False,
3790
3399
directory=None,
3791
3400
preview=False,
3792
interactive=False,
3793
3401
):
3794
3402
if merge_type is None:
3795
3403
merge_type = _mod_merge.Merge3Merger
3801
3409
verified = 'inapplicable'
3802
3410
tree = WorkingTree.open_containing(directory)[0]
3803
3411
3412
# die as quickly as possible if there are uncommitted changes
3804
3413
try:
3805
3414
basis_tree = tree.revision_tree(tree.last_revision())
3806
3415
except errors.NoSuchRevision:
3807
3416
basis_tree = tree.basis_tree()
3808
3809
# die as quickly as possible if there are uncommitted changes
3810
3417
if not force:
3811
if tree.has_changes():
3418
changes = tree.changes_from(basis_tree)
3419
if changes.has_changed():
3812
3420
raise errors.UncommittedChanges(tree)
3813
3421
3814
3422
view_info = _get_view_info_for_change_reporter(tree)
3815
3423
change_reporter = delta._ChangeReporter(
3816
3424
unversioned_filter=tree.is_ignored, view_info=view_info)
3817
pb = ui.ui_factory.nested_progress_bar()
3818
self.add_cleanup(pb.finished)
3819
self.add_cleanup(tree.lock_write().unlock)
3820
if location is not None:
3821
try:
3822
mergeable = bundle.read_mergeable_from_url(location,
3823
possible_transports=possible_transports)
3824
except errors.NotABundle:
3825
mergeable = None
3425
cleanups = []
3426
try:
3427
pb = ui.ui_factory.nested_progress_bar()
3428
cleanups.append(pb.finished)
3429
tree.lock_write()
3430
cleanups.append(tree.unlock)
3431
if location is not None:
3432
try:
3433
mergeable = bundle.read_mergeable_from_url(location,
3434
possible_transports=possible_transports)
3435
except errors.NotABundle:
3436
mergeable = None
3437
else:
3438
if uncommitted:
3439
raise errors.BzrCommandError('Cannot use --uncommitted'
3440
' with bundles or merge directives.')
3441
3442
if revision is not None:
3443
raise errors.BzrCommandError(
3444
'Cannot use -r with merge directives or bundles')
3445
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3446
mergeable, pb)
3447
3448
if merger is None and uncommitted:
3449
if revision is not None and len(revision) > 0:
3450
raise errors.BzrCommandError('Cannot use --uncommitted and'
3451
' --revision at the same time.')
3452
location = self._select_branch_location(tree, location)[0]
3453
other_tree, other_path = WorkingTree.open_containing(location)
3454
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree,
3455
pb)
3456
allow_pending = False
3457
if other_path != '':
3458
merger.interesting_files = [other_path]
3459
3460
if merger is None:
3461
merger, allow_pending = self._get_merger_from_branch(tree,
3462
location, revision, remember, possible_transports, pb)
3463
3464
merger.merge_type = merge_type
3465
merger.reprocess = reprocess
3466
merger.show_base = show_base
3467
self.sanity_check_merger(merger)
3468
if (merger.base_rev_id == merger.other_rev_id and
3469
merger.other_rev_id is not None):
3470
note('Nothing to do.')
3471
return 0
3472
if pull:
3473
if merger.interesting_files is not None:
3474
raise errors.BzrCommandError('Cannot pull individual files')
3475
if (merger.base_rev_id == tree.last_revision()):
3476
result = tree.pull(merger.other_branch, False,
3477
merger.other_rev_id)
3478
result.report(self.outf)
3479
return 0
3480
merger.check_basis(False)
3481
if preview:
3482
return self._do_preview(merger)
3826
3483
else:
3827
if uncommitted:
3828
raise errors.BzrCommandError('Cannot use --uncommitted'
3829
' with bundles or merge directives.')
3830
3831
if revision is not None:
3832
raise errors.BzrCommandError(
3833
'Cannot use -r with merge directives or bundles')
3834
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3835
mergeable, None)
3836
3837
if merger is None and uncommitted:
3838
if revision is not None and len(revision) > 0:
3839
raise errors.BzrCommandError('Cannot use --uncommitted and'
3840
' --revision at the same time.')
3841
merger = self.get_merger_from_uncommitted(tree, location, None)
3842
allow_pending = False
3843
3844
if merger is None:
3845
merger, allow_pending = self._get_merger_from_branch(tree,
3846
location, revision, remember, possible_transports, None)
3847
3848
merger.merge_type = merge_type
3849
merger.reprocess = reprocess
3850
merger.show_base = show_base
3851
self.sanity_check_merger(merger)
3852
if (merger.base_rev_id == merger.other_rev_id and
3853
merger.other_rev_id is not None):
3854
note('Nothing to do.')
3855
return 0
3856
if pull:
3857
if merger.interesting_files is not None:
3858
raise errors.BzrCommandError('Cannot pull individual files')
3859
if (merger.base_rev_id == tree.last_revision()):
3860
result = tree.pull(merger.other_branch, False,
3861
merger.other_rev_id)
3862
result.report(self.outf)
3863
return 0
3864
if merger.this_basis is None:
3865
raise errors.BzrCommandError(
3866
"This branch has no commits."
3867
" (perhaps you would prefer 'bzr pull')")
3868
if preview:
3869
return self._do_preview(merger)
3870
elif interactive:
3871
return self._do_interactive(merger)
3872
else:
3873
return self._do_merge(merger, change_reporter, allow_pending,
3874
verified)
3875
3876
def _get_preview(self, merger):
3484
return self._do_merge(merger, change_reporter, allow_pending,
3485
verified)
3486
finally:
3487
for cleanup in reversed(cleanups):
3488
cleanup()
3489
3490
def _do_preview(self, merger):
3491
from bzrlib.diff import show_diff_trees
3877
3492
tree_merger = merger.make_merger()
3878
3493
tt = tree_merger.make_preview_transform()
3879
self.add_cleanup(tt.finalize)
3880
result_tree = tt.get_preview_tree()
3881
return result_tree
3882
3883
def _do_preview(self, merger):
3884
from bzrlib.diff import show_diff_trees
3885
result_tree = self._get_preview(merger)
3886
show_diff_trees(merger.this_tree, result_tree, self.outf,
3887
old_label='', new_label='')
3494
try:
3495
result_tree = tt.get_preview_tree()
3496
show_diff_trees(merger.this_tree, result_tree, self.outf,
3497
old_label='', new_label='')
3498
finally:
3499
tt.finalize()
3888
3500
3889
3501
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3890
3502
merger.change_reporter = change_reporter
3898
3510
else:
3899
3511
return 0
3900
3512
3901
def _do_interactive(self, merger):
3902
"""Perform an interactive merge.
3903
3904
This works by generating a preview tree of the merge, then using
3905
Shelver to selectively remove the differences between the working tree
3906
and the preview tree.
3907
"""
3908
from bzrlib import shelf_ui
3909
result_tree = self._get_preview(merger)
3910
writer = bzrlib.option.diff_writer_registry.get()
3911
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3912
reporter=shelf_ui.ApplyReporter(),
3913
diff_writer=writer(sys.stdout))
3914
try:
3915
shelver.run()
3916
finally:
3917
shelver.finalize()
3918
3919
3513
def sanity_check_merger(self, merger):
3920
3514
if (merger.show_base and
3921
3515
not merger.merge_type is _mod_merge.Merge3Merger):
3956
3550
base_branch, base_path = Branch.open_containing(base_loc,
3957
3551
possible_transports)
3958
3552
# Find the revision ids
3959
other_revision_id = None
3960
base_revision_id = None
3961
if revision is not None:
3962
if len(revision) >= 1:
3963
other_revision_id = revision[-1].as_revision_id(other_branch)
3964
if len(revision) == 2:
3965
base_revision_id = revision[0].as_revision_id(base_branch)
3966
if other_revision_id is None:
3553
if revision is None or len(revision) < 1 or revision[-1] is None:
3967
3554
other_revision_id = _mod_revision.ensure_null(
3968
3555
other_branch.last_revision())
3556
else:
3557
other_revision_id = revision[-1].as_revision_id(other_branch)
3558
if (revision is not None and len(revision) == 2
3559
and revision[0] is not None):
3560
base_revision_id = revision[0].as_revision_id(base_branch)
3561
else:
3562
base_revision_id = None
3969
3563
# Remember where we merge from
3970
3564
if ((remember or tree.branch.get_submit_branch() is None) and
3971
3565
user_location is not None):
3980
3574
allow_pending = True
3981
3575
return merger, allow_pending
3982
3576
3983
def get_merger_from_uncommitted(self, tree, location, pb):
3984
"""Get a merger for uncommitted changes.
3985
3986
:param tree: The tree the merger should apply to.
3987
:param location: The location containing uncommitted changes.
3988
:param pb: The progress bar to use for showing progress.
3989
"""
3990
location = self._select_branch_location(tree, location)[0]
3991
other_tree, other_path = WorkingTree.open_containing(location)
3992
merger = _mod_merge.Merger.from_uncommitted(tree, other_tree, pb)
3993
if other_path != '':
3994
merger.interesting_files = [other_path]
3995
return merger
3996
3997
3577
def _select_branch_location(self, tree, user_location, revision=None,
3998
3578
index=None):
3999
3579
"""Select a branch location, according to possible inputs.
4043
3623
4044
3624
4045
3625
class cmd_remerge(Command):
4046
__doc__ = """Redo a merge.
3626
"""Redo a merge.
4047
3627
4048
3628
Use this if you want to try a different merge technique while resolving
4049
3629
conflicts. Some merge techniques are better than others, and remerge
4074
3654
4075
3655
def run(self, file_list=None, merge_type=None, show_base=False,
4076
3656
reprocess=False):
4077
from bzrlib.conflicts import restore
4078
3657
if merge_type is None:
4079
3658
merge_type = _mod_merge.Merge3Merger
4080
3659
tree, file_list = tree_files(file_list)
4081
self.add_cleanup(tree.lock_write().unlock)
4082
parents = tree.get_parent_ids()
4083
if len(parents) != 2:
4084
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4085
" merges. Not cherrypicking or"
4086
" multi-merges.")
4087
repository = tree.branch.repository
4088
interesting_ids = None
4089
new_conflicts = []
4090
conflicts = tree.conflicts()
4091
if file_list is not None:
4092
interesting_ids = set()
4093
for filename in file_list:
4094
file_id = tree.path2id(filename)
4095
if file_id is None:
4096
raise errors.NotVersionedError(filename)
4097
interesting_ids.add(file_id)
4098
if tree.kind(file_id) != "directory":
4099
continue
3660
tree.lock_write()
3661
try:
3662
parents = tree.get_parent_ids()
3663
if len(parents) != 2:
3664
raise errors.BzrCommandError("Sorry, remerge only works after normal"
3665
" merges. Not cherrypicking or"
3666
" multi-merges.")
3667
repository = tree.branch.repository
3668
interesting_ids = None
3669
new_conflicts = []
3670
conflicts = tree.conflicts()
3671
if file_list is not None:
3672
interesting_ids = set()
3673
for filename in file_list:
3674
file_id = tree.path2id(filename)
3675
if file_id is None:
3676
raise errors.NotVersionedError(filename)
3677
interesting_ids.add(file_id)
3678
if tree.kind(file_id) != "directory":
3679
continue
4100
3680
4101
for name, ie in tree.inventory.iter_entries(file_id):
4102
interesting_ids.add(ie.file_id)
4103
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4104
else:
4105
# Remerge only supports resolving contents conflicts
4106
allowed_conflicts = ('text conflict', 'contents conflict')
4107
restore_files = [c.path for c in conflicts
4108
if c.typestring in allowed_conflicts]
4109
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4110
tree.set_conflicts(ConflictList(new_conflicts))
4111
if file_list is not None:
4112
restore_files = file_list
4113
for filename in restore_files:
3681
for name, ie in tree.inventory.iter_entries(file_id):
3682
interesting_ids.add(ie.file_id)
3683
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
3684
else:
3685
# Remerge only supports resolving contents conflicts
3686
allowed_conflicts = ('text conflict', 'contents conflict')
3687
restore_files = [c.path for c in conflicts
3688
if c.typestring in allowed_conflicts]
3689
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
3690
tree.set_conflicts(ConflictList(new_conflicts))
3691
if file_list is not None:
3692
restore_files = file_list
3693
for filename in restore_files:
3694
try:
3695
restore(tree.abspath(filename))
3696
except errors.NotConflicted:
3697
pass
3698
# Disable pending merges, because the file texts we are remerging
3699
# have not had those merges performed. If we use the wrong parents
3700
# list, we imply that the working tree text has seen and rejected
3701
# all the changes from the other tree, when in fact those changes
3702
# have not yet been seen.
3703
pb = ui.ui_factory.nested_progress_bar()
3704
tree.set_parent_ids(parents[:1])
4114
3705
try:
4115
restore(tree.abspath(filename))
4116
except errors.NotConflicted:
4117
pass
4118
# Disable pending merges, because the file texts we are remerging
4119
# have not had those merges performed. If we use the wrong parents
4120
# list, we imply that the working tree text has seen and rejected
4121
# all the changes from the other tree, when in fact those changes
4122
# have not yet been seen.
4123
tree.set_parent_ids(parents[:1])
4124
try:
4125
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4126
merger.interesting_ids = interesting_ids
4127
merger.merge_type = merge_type
4128
merger.show_base = show_base
4129
merger.reprocess = reprocess
4130
conflicts = merger.do_merge()
3706
merger = _mod_merge.Merger.from_revision_ids(pb,
3707
tree, parents[1])
3708
merger.interesting_ids = interesting_ids
3709
merger.merge_type = merge_type
3710
merger.show_base = show_base
3711
merger.reprocess = reprocess
3712
conflicts = merger.do_merge()
3713
finally:
3714
tree.set_parent_ids(parents)
3715
pb.finished()
4131
3716
finally:
4132
tree.set_parent_ids(parents)
3717
tree.unlock()
4133
3718
if conflicts > 0:
4134
3719
return 1
4135
3720
else:
4137
3722
4138
3723
4139
3724
class cmd_revert(Command):
4140
__doc__ = """Revert files to a previous revision.
3725
"""Revert files to a previous revision.
4141
3726
4142
3727
Giving a list of files will revert only those files. Otherwise, all files
4143
3728
will be reverted. If the revision is not specified with '--revision', the
4157
3742
name. If you name a directory, all the contents of that directory will be
4158
3743
reverted.
4159
3744
4160
If you have newly added files since the target revision, they will be
4161
removed. If the files to be removed have been changed, backups will be
4162
created as above. Directories containing unknown files will not be
4163
deleted.
3745
Any files that have been newly added since that revision will be deleted,
3746
with a backup kept if appropriate. Directories containing unknown files
3747
will not be deleted.
4164
3748
4165
The working tree contains a list of revisions that have been merged but
4166
not yet committed. These revisions will be included as additional parents
4167
of the next commit. Normally, using revert clears that list as well as
4168
reverting the files. If any files are specified, revert leaves the list
4169
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4170
.`` in the tree root to revert all files but keep the recorded merges,
4171
and ``bzr revert --forget-merges`` to clear the pending merge list without
3749
The working tree contains a list of pending merged revisions, which will
3750
be included as parents in the next commit. Normally, revert clears that
3751
list as well as reverting the files. If any files are specified, revert
3752
leaves the pending merge list alone and reverts only the files. Use "bzr
3753
revert ." in the tree root to revert all files but keep the merge record,
3754
and "bzr revert --forget-merges" to clear the pending merge list without
4172
3755
reverting any files.
4173
4174
Using "bzr revert --forget-merges", it is possible to apply all of the
4175
changes from a branch in a single revision. To do this, perform the merge
4176
as desired. Then doing revert with the "--forget-merges" option will keep
4177
the content of the tree as it was, but it will clear the list of pending
4178
merges. The next commit will then contain all of the changes that are
4179
present in the other branch, but without any other parent revisions.
4180
Because this technique forgets where these changes originated, it may
4181
cause additional conflicts on later merges involving the same source and
4182
target branches.
4183
3756
"""
4184
3757
4185
3758
_see_also = ['cat', 'export']
4194
3767
def run(self, revision=None, no_backup=False, file_list=None,
4195
3768
forget_merges=None):
4196
3769
tree, file_list = tree_files(file_list)
4197
self.add_cleanup(tree.lock_tree_write().unlock)
4198
if forget_merges:
4199
tree.set_parent_ids(tree.get_parent_ids()[:1])
4200
else:
4201
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
3770
tree.lock_write()
3771
try:
3772
if forget_merges:
3773
tree.set_parent_ids(tree.get_parent_ids()[:1])
3774
else:
3775
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
3776
finally:
3777
tree.unlock()
4202
3778
4203
3779
@staticmethod
4204
3780
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4205
3781
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4206
tree.revert(file_list, rev_tree, not no_backup, None,
4207
report_changes=True)
3782
pb = ui.ui_factory.nested_progress_bar()
3783
try:
3784
tree.revert(file_list, rev_tree, not no_backup, pb,
3785
report_changes=True)
3786
finally:
3787
pb.finished()
4208
3788
4209
3789
4210
3790
class cmd_assert_fail(Command):
4211
__doc__ = """Test reporting of assertion failures"""
3791
"""Test reporting of assertion failures"""
4212
3792
# intended just for use in testing
4213
3793
4214
3794
hidden = True
4218
3798
4219
3799
4220
3800
class cmd_help(Command):
4221
__doc__ = """Show help on a command or other topic.
3801
"""Show help on a command or other topic.
4222
3802
"""
4223
3803
4224
3804
_see_also = ['topics']
4237
3817
4238
3818
4239
3819
class cmd_shell_complete(Command):
4240
__doc__ = """Show appropriate completions for context.
3820
"""Show appropriate completions for context.
4241
3821
4242
3822
For a list of all available commands, say 'bzr shell-complete'.
4243
3823
"""
4252
3832
4253
3833
4254
3834
class cmd_missing(Command):
4255
__doc__ = """Show unmerged/unpulled revisions between two branches.
3835
"""Show unmerged/unpulled revisions between two branches.
4256
3836
4257
3837
OTHER_BRANCH may be local or remote.
4258
3838
4259
3839
To filter on a range of revisions, you can use the command -r begin..end
4260
3840
-r revision requests a specific revision, -r ..end or -r begin.. are
4261
3841
also valid.
4262
4263
:Exit values:
4264
1 - some missing revisions
4265
0 - no missing revisions
4266
3842
4267
3843
:Examples:
4268
3844
4306
3882
type=_parse_revision_str,
4307
3883
help='Filter on local branch revisions (inclusive). '
4308
3884
'See "help revisionspec" for details.'),
4309
Option('include-merges',
4310
'Show all revisions in addition to the mainline ones.'),
3885
Option('include-merges', 'Show merged revisions.'),
4311
3886
]
4312
3887
encoding_type = 'replace'
4313
3888
4336
3911
restrict = 'remote'
4337
3912
4338
3913
local_branch = Branch.open_containing(u".")[0]
4339
self.add_cleanup(local_branch.lock_read().unlock)
4340
4341
3914
parent = local_branch.get_parent()
4342
3915
if other_branch is None:
4343
3916
other_branch = parent
4352
3925
remote_branch = Branch.open(other_branch)
4353
3926
if remote_branch.base == local_branch.base:
4354
3927
remote_branch = local_branch
4355
else:
4356
self.add_cleanup(remote_branch.lock_read().unlock)
4357
3928
4358
3929
local_revid_range = _revision_range_to_revid_range(
4359
3930
_get_revision_range(my_revision, local_branch,
4363
3934
_get_revision_range(revision,
4364
3935
remote_branch, self.name()))
4365
3936
4366
local_extra, remote_extra = find_unmerged(
4367
local_branch, remote_branch, restrict,
4368
backward=not reverse,
4369
include_merges=include_merges,
4370
local_revid_range=local_revid_range,
4371
remote_revid_range=remote_revid_range)
4372
4373
if log_format is None:
4374
registry = log.log_formatter_registry
4375
log_format = registry.get_default(local_branch)
4376
lf = log_format(to_file=self.outf,
4377
show_ids=show_ids,
4378
show_timezone='original')
4379
4380
status_code = 0
4381
if local_extra and not theirs_only:
4382
message("You have %d extra revision(s):\n" %
4383
len(local_extra))
4384
for revision in iter_log_revisions(local_extra,
4385
local_branch.repository,
4386
verbose):
4387
lf.log_revision(revision)
4388
printed_local = True
4389
status_code = 1
4390
else:
4391
printed_local = False
4392
4393
if remote_extra and not mine_only:
4394
if printed_local is True:
4395
message("\n\n\n")
4396
message("You are missing %d revision(s):\n" %
4397
len(remote_extra))
4398
for revision in iter_log_revisions(remote_extra,
4399
remote_branch.repository,
4400
verbose):
4401
lf.log_revision(revision)
4402
status_code = 1
4403
4404
if mine_only and not local_extra:
4405
# We checked local, and found nothing extra
4406
message('This branch is up to date.\n')
4407
elif theirs_only and not remote_extra:
4408
# We checked remote, and found nothing extra
4409
message('Other branch is up to date.\n')
4410
elif not (mine_only or theirs_only or local_extra or
4411
remote_extra):
4412
# We checked both branches, and neither one had extra
4413
# revisions
4414
message("Branches are up to date.\n")
4415
self.cleanup_now()
3937
local_branch.lock_read()
3938
try:
3939
remote_branch.lock_read()
3940
try:
3941
local_extra, remote_extra = find_unmerged(
3942
local_branch, remote_branch, restrict,
3943
backward=not reverse,
3944
include_merges=include_merges,
3945
local_revid_range=local_revid_range,
3946
remote_revid_range=remote_revid_range)
3947
3948
if log_format is None:
3949
registry = log.log_formatter_registry
3950
log_format = registry.get_default(local_branch)
3951
lf = log_format(to_file=self.outf,
3952
show_ids=show_ids,
3953
show_timezone='original')
3954
3955
status_code = 0
3956
if local_extra and not theirs_only:
3957
message("You have %d extra revision(s):\n" %
3958
len(local_extra))
3959
for revision in iter_log_revisions(local_extra,
3960
local_branch.repository,
3961
verbose):
3962
lf.log_revision(revision)
3963
printed_local = True
3964
status_code = 1
3965
else:
3966
printed_local = False
3967
3968
if remote_extra and not mine_only:
3969
if printed_local is True:
3970
message("\n\n\n")
3971
message("You are missing %d revision(s):\n" %
3972
len(remote_extra))
3973
for revision in iter_log_revisions(remote_extra,
3974
remote_branch.repository,
3975
verbose):
3976
lf.log_revision(revision)
3977
status_code = 1
3978
3979
if mine_only and not local_extra:
3980
# We checked local, and found nothing extra
3981
message('This branch is up to date.\n')
3982
elif theirs_only and not remote_extra:
3983
# We checked remote, and found nothing extra
3984
message('Other branch is up to date.\n')
3985
elif not (mine_only or theirs_only or local_extra or
3986
remote_extra):
3987
# We checked both branches, and neither one had extra
3988
# revisions
3989
message("Branches are up to date.\n")
3990
finally:
3991
remote_branch.unlock()
3992
finally:
3993
local_branch.unlock()
4416
3994
if not status_code and parent is None and other_branch is not None:
4417
self.add_cleanup(local_branch.lock_write().unlock)
4418
# handle race conditions - a parent might be set while we run.
4419
if local_branch.get_parent() is None:
4420
local_branch.set_parent(remote_branch.base)
3995
local_branch.lock_write()
3996
try:
3997
# handle race conditions - a parent might be set while we run.
3998
if local_branch.get_parent() is None:
3999
local_branch.set_parent(remote_branch.base)
4000
finally:
4001
local_branch.unlock()
4421
4002
return status_code
4422
4003
4423
4004
4424
4005
class cmd_pack(Command):
4425
__doc__ = """Compress the data within a repository.
4426
4427
This operation compresses the data within a bazaar repository. As
4428
bazaar supports automatic packing of repository, this operation is
4429
normally not required to be done manually.
4430
4431
During the pack operation, bazaar takes a backup of existing repository
4432
data, i.e. pack files. This backup is eventually removed by bazaar
4433
automatically when it is safe to do so. To save disk space by removing
4434
the backed up pack files, the --clean-obsolete-packs option may be
4435
used.
4436
4437
Warning: If you use --clean-obsolete-packs and your machine crashes
4438
during or immediately after repacking, you may be left with a state
4439
where the deletion has been written to disk but the new packs have not
4440
been. In this case the repository may be unusable.
4441
"""
4006
"""Compress the data within a repository."""
4442
4007
4443
4008
_see_also = ['repositories']
4444
4009
takes_args = ['branch_or_repo?']
4445
takes_options = [
4446
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4447
]
4448
4010
4449
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4011
def run(self, branch_or_repo='.'):
4450
4012
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4451
4013
try:
4452
4014
branch = dir.open_branch()
4453
4015
repository = branch.repository
4454
4016
except errors.NotBranchError:
4455
4017
repository = dir.open_repository()
4456
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4018
repository.pack()
4457
4019
4458
4020
4459
4021
class cmd_plugins(Command):
4460
__doc__ = """List the installed plugins.
4022
"""List the installed plugins.
4461
4023
4462
4024
This command displays the list of installed plugins including
4463
4025
version of plugin and a short description of each.
4470
4032
adding new commands, providing additional network transports and
4471
4033
customizing log output.
4472
4034
4473
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
4474
for further information on plugins including where to find them and how to
4475
install them. Instructions are also provided there on how to write new
4476
plugins using the Python programming language.
4035
See the Bazaar web site, http://bazaar-vcs.org, for further
4036
information on plugins including where to find them and how to
4037
install them. Instructions are also provided there on how to
4038
write new plugins using the Python programming language.
4477
4039
"""
4478
4040
takes_options = ['verbose']
4479
4041
4494
4056
doc = '(no description)'
4495
4057
result.append((name_ver, doc, plugin.path()))
4496
4058
for name_ver, doc, path in sorted(result):
4497
self.outf.write("%s\n" % name_ver)
4498
self.outf.write(" %s\n" % doc)
4059
print name_ver
4060
print ' ', doc
4499
4061
if verbose:
4500
self.outf.write(" %s\n" % path)
4501
self.outf.write("\n")
4062
print ' ', path
4063
print
4502
4064
4503
4065
4504
4066
class cmd_testament(Command):
4505
__doc__ = """Show testament (signing-form) of a revision."""
4067
"""Show testament (signing-form) of a revision."""
4506
4068
takes_options = [
4507
4069
'revision',
4508
4070
Option('long', help='Produce long-format testament.'),
4520
4082
b = Branch.open_containing(branch)[0]
4521
4083
else:
4522
4084
b = Branch.open(branch)
4523
self.add_cleanup(b.lock_read().unlock)
4524
if revision is None:
4525
rev_id = b.last_revision()
4526
else:
4527
rev_id = revision[0].as_revision_id(b)
4528
t = testament_class.from_revision(b.repository, rev_id)
4529
if long:
4530
sys.stdout.writelines(t.as_text_lines())
4531
else:
4532
sys.stdout.write(t.as_short_text())
4085
b.lock_read()
4086
try:
4087
if revision is None:
4088
rev_id = b.last_revision()
4089
else:
4090
rev_id = revision[0].as_revision_id(b)
4091
t = testament_class.from_revision(b.repository, rev_id)
4092
if long:
4093
sys.stdout.writelines(t.as_text_lines())
4094
else:
4095
sys.stdout.write(t.as_short_text())
4096
finally:
4097
b.unlock()
4533
4098
4534
4099
4535
4100
class cmd_annotate(Command):
4536
__doc__ = """Show the origin of each line in a file.
4101
"""Show the origin of each line in a file.
4537
4102
4538
4103
This prints out the given file with an annotation on the left side
4539
4104
indicating which revision, author and date introduced the change.
4550
4115
Option('long', help='Show commit date in annotations.'),
4551
4116
'revision',
4552
4117
'show-ids',
4553
'directory',
4554
4118
]
4555
4119
encoding_type = 'exact'
4556
4120
4557
4121
@display_command
4558
4122
def run(self, filename, all=False, long=False, revision=None,
4559
show_ids=False, directory=None):
4123
show_ids=False):
4560
4124
from bzrlib.annotate import annotate_file, annotate_file_tree
4561
4125
wt, branch, relpath = \
4562
_open_directory_or_containing_tree_or_branch(filename, directory)
4563
if wt is not None:
4564
self.add_cleanup(wt.lock_read().unlock)
4565
else:
4566
self.add_cleanup(branch.lock_read().unlock)
4567
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4568
self.add_cleanup(tree.lock_read().unlock)
4569
if wt is not None:
4570
file_id = wt.path2id(relpath)
4571
else:
4572
file_id = tree.path2id(relpath)
4573
if file_id is None:
4574
raise errors.NotVersionedError(filename)
4575
file_version = tree.inventory[file_id].revision
4576
if wt is not None and revision is None:
4577
# If there is a tree and we're not annotating historical
4578
# versions, annotate the working tree's content.
4579
annotate_file_tree(wt, file_id, self.outf, long, all,
4580
show_ids=show_ids)
4581
else:
4582
annotate_file(branch, file_version, file_id, long, all, self.outf,
4583
show_ids=show_ids)
4126
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4127
if wt is not None:
4128
wt.lock_read()
4129
else:
4130
branch.lock_read()
4131
try:
4132
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4133
if wt is not None:
4134
file_id = wt.path2id(relpath)
4135
else:
4136
file_id = tree.path2id(relpath)
4137
if file_id is None:
4138
raise errors.NotVersionedError(filename)
4139
file_version = tree.inventory[file_id].revision
4140
if wt is not None and revision is None:
4141
# If there is a tree and we're not annotating historical
4142
# versions, annotate the working tree's content.
4143
annotate_file_tree(wt, file_id, self.outf, long, all,
4144
show_ids=show_ids)
4145
else:
4146
annotate_file(branch, file_version, file_id, long, all, self.outf,
4147
show_ids=show_ids)
4148
finally:
4149
if wt is not None:
4150
wt.unlock()
4151
else:
4152
branch.unlock()
4584
4153
4585
4154
4586
4155
class cmd_re_sign(Command):
4587
__doc__ = """Create a digital signature for an existing revision."""
4156
"""Create a digital signature for an existing revision."""
4588
4157
# TODO be able to replace existing ones.
4589
4158
4590
4159
hidden = True # is this right ?
4591
4160
takes_args = ['revision_id*']
4592
takes_options = ['directory', 'revision']
4161
takes_options = ['revision']
4593
4162
4594
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4163
def run(self, revision_id_list=None, revision=None):
4595
4164
if revision_id_list is not None and revision is not None:
4596
4165
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4597
4166
if revision_id_list is None and revision is None:
4598
4167
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4599
b = WorkingTree.open_containing(directory)[0].branch
4600
self.add_cleanup(b.lock_write().unlock)
4601
return self._run(b, revision_id_list, revision)
4168
b = WorkingTree.open_containing(u'.')[0].branch
4169
b.lock_write()
4170
try:
4171
return self._run(b, revision_id_list, revision)
4172
finally:
4173
b.unlock()
4602
4174
4603
4175
def _run(self, b, revision_id_list, revision):
4604
4176
import bzrlib.gpg as gpg
4649
4221
4650
4222
4651
4223
class cmd_bind(Command):
4652
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4653
If no branch is supplied, rebind to the last bound location.
4224
"""Convert the current branch into a checkout of the supplied branch.
4654
4225
4655
4226
Once converted into a checkout, commits must succeed on the master branch
4656
4227
before they will be applied to the local branch.
4657
4228
4658
4229
Bound branches use the nickname of its master branch unless it is set
4659
locally, in which case binding will update the local nickname to be
4230
locally, in which case binding will update the the local nickname to be
4660
4231
that of the master.
4661
4232
"""
4662
4233
4663
4234
_see_also = ['checkouts', 'unbind']
4664
4235
takes_args = ['location?']
4665
takes_options = ['directory']
4236
takes_options = []
4666
4237
4667
def run(self, location=None, directory=u'.'):
4668
b, relpath = Branch.open_containing(directory)
4238
def run(self, location=None):
4239
b, relpath = Branch.open_containing(u'.')
4669
4240
if location is None:
4670
4241
try:
4671
4242
location = b.get_old_bound_location()
4674
4245
'This format does not remember old locations.')
4675
4246
else:
4676
4247
if location is None:
4677
if b.get_bound_location() is not None:
4678
raise errors.BzrCommandError('Branch is already bound')
4679
else:
4680
raise errors.BzrCommandError('No location supplied '
4681
'and no previous location known')
4248
raise errors.BzrCommandError('No location supplied and no '
4249
'previous location known')
4682
4250
b_other = Branch.open(location)
4683
4251
try:
4684
4252
b.bind(b_other)
4690
4258
4691
4259
4692
4260
class cmd_unbind(Command):
4693
__doc__ = """Convert the current checkout into a regular branch.
4261
"""Convert the current checkout into a regular branch.
4694
4262
4695
4263
After unbinding, the local branch is considered independent and subsequent
4696
4264
commits will be local only.
4698
4266
4699
4267
_see_also = ['checkouts', 'bind']
4700
4268
takes_args = []
4701
takes_options = ['directory']
4269
takes_options = []
4702
4270
4703
def run(self, directory=u'.'):
4704
b, relpath = Branch.open_containing(directory)
4271
def run(self):
4272
b, relpath = Branch.open_containing(u'.')
4705
4273
if not b.unbind():
4706
4274
raise errors.BzrCommandError('Local branch is not bound')
4707
4275
4708
4276
4709
4277
class cmd_uncommit(Command):
4710
__doc__ = """Remove the last committed revision.
4278
"""Remove the last committed revision.
4711
4279
4712
4280
--verbose will print out what is being removed.
4713
4281
--dry-run will go through all the motions, but not actually
4753
4321
b = control.open_branch()
4754
4322
4755
4323
if tree is not None:
4756
self.add_cleanup(tree.lock_write().unlock)
4324
tree.lock_write()
4757
4325
else:
4758
self.add_cleanup(b.lock_write().unlock)
4759
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4326
b.lock_write()
4327
try:
4328
return self._run(b, tree, dry_run, verbose, revision, force,
4329
local=local)
4330
finally:
4331
if tree is not None:
4332
tree.unlock()
4333
else:
4334
b.unlock()
4760
4335
4761
4336
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4762
4337
from bzrlib.log import log_formatter, show_log
4794
4369
end_revision=last_revno)
4795
4370
4796
4371
if dry_run:
4797
self.outf.write('Dry-run, pretending to remove'
4798
' the above revisions.\n')
4372
print 'Dry-run, pretending to remove the above revisions.'
4373
if not force:
4374
val = raw_input('Press <enter> to continue')
4799
4375
else:
4800
self.outf.write('The above revision(s) will be removed.\n')
4801
4802
if not force:
4803
if not ui.ui_factory.get_boolean('Are you sure'):
4804
self.outf.write('Canceled')
4805
return 0
4376
print 'The above revision(s) will be removed.'
4377
if not force:
4378
val = raw_input('Are you sure [y/N]? ')
4379
if val.lower() not in ('y', 'yes'):
4380
print 'Canceled'
4381
return 0
4806
4382
4807
4383
mutter('Uncommitting from {%s} to {%s}',
4808
4384
last_rev_id, rev_id)
4809
4385
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4810
4386
revno=revno, local=local)
4811
self.outf.write('You can restore the old tip by running:\n'
4812
' bzr pull . -r revid:%s\n' % last_rev_id)
4387
note('You can restore the old tip by running:\n'
4388
' bzr pull . -r revid:%s', last_rev_id)
4813
4389
4814
4390
4815
4391
class cmd_break_lock(Command):
4816
__doc__ = """Break a dead lock on a repository, branch or working directory.
4392
"""Break a dead lock on a repository, branch or working directory.
4817
4393
4818
4394
CAUTION: Locks should only be broken when you are sure that the process
4819
4395
holding the lock has been stopped.
4820
4396
4821
You can get information on what locks are open via the 'bzr info
4822
[location]' command.
4397
You can get information on what locks are open via the 'bzr info' command.
4823
4398
4824
4399
:Examples:
4825
4400
bzr break-lock
4826
bzr break-lock bzr+ssh://example.com/bzr/foo
4827
4401
"""
4828
4402
takes_args = ['location?']
4829
4403
4838
4412
4839
4413
4840
4414
class cmd_wait_until_signalled(Command):
4841
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4415
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4842
4416
4843
4417
This just prints a line to signal when it is ready, then blocks on stdin.
4844
4418
"""
4852
4426
4853
4427
4854
4428
class cmd_serve(Command):
4855
__doc__ = """Run the bzr server."""
4429
"""Run the bzr server."""
4856
4430
4857
4431
aliases = ['server']
4858
4432
4859
4433
takes_options = [
4860
4434
Option('inet',
4861
4435
help='Serve on stdin/out for use from inetd or sshd.'),
4862
RegistryOption('protocol',
4863
help="Protocol to serve.",
4864
lazy_registry=('bzrlib.transport', 'transport_server_registry'),
4865
value_switches=True),
4866
4436
Option('port',
4867
4437
help='Listen for connections on nominated port of the form '
4868
4438
'[hostname:]portnumber. Passing 0 as the port number will '
4869
'result in a dynamically allocated port. The default port '
4870
'depends on the protocol.',
4439
'result in a dynamically allocated port. The default port is '
4440
'4155.',
4871
4441
type=str),
4872
custom_help('directory',
4873
help='Serve contents of this directory.'),
4442
Option('directory',
4443
help='Serve contents of this directory.',
4444
type=unicode),
4874
4445
Option('allow-writes',
4875
4446
help='By default the server is a readonly server. Supplying '
4876
4447
'--allow-writes enables write access to the contents of '
4877
'the served directory and below. Note that ``bzr serve`` '
4878
'does not perform authentication, so unless some form of '
4879
'external authentication is arranged supplying this '
4880
'option leads to global uncontrolled write access to your '
4881
'file system.'
4448
'the served directory and below.'
4882
4449
),
4883
4450
]
4884
4451
4452
def run_smart_server(self, smart_server):
4453
"""Run 'smart_server' forever, with no UI output at all."""
4454
# For the duration of this server, no UI output is permitted. note
4455
# that this may cause problems with blackbox tests. This should be
4456
# changed with care though, as we dont want to use bandwidth sending
4457
# progress over stderr to smart server clients!
4458
from bzrlib import lockdir
4459
old_factory = ui.ui_factory
4460
old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
4461
try:
4462
ui.ui_factory = ui.SilentUIFactory()
4463
lockdir._DEFAULT_TIMEOUT_SECONDS = 0
4464
smart_server.serve()
4465
finally:
4466
ui.ui_factory = old_factory
4467
lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
4468
4885
4469
def get_host_and_port(self, port):
4886
4470
"""Return the host and port to run the smart server on.
4887
4471
4888
If 'port' is None, None will be returned for the host and port.
4472
If 'port' is None, the default host (`medium.BZR_DEFAULT_INTERFACE`)
4473
and port (`medium.BZR_DEFAULT_PORT`) will be used.
4889
4474
4890
4475
If 'port' has a colon in it, the string before the colon will be
4891
4476
interpreted as the host.
4894
4479
:return: A tuple of (host, port), where 'host' is a host name or IP,
4895
4480
and port is an integer TCP/IP port.
4896
4481
"""
4897
host = None
4898
if port is not None:
4482
from bzrlib.smart import medium
4483
host = medium.BZR_DEFAULT_INTERFACE
4484
if port is None:
4485
port = medium.BZR_DEFAULT_PORT
4486
else:
4899
4487
if ':' in port:
4900
4488
host, port = port.split(':')
4901
4489
port = int(port)
4902
4490
return host, port
4903
4491
4904
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4905
protocol=None):
4906
from bzrlib.transport import get_transport, transport_server_registry
4492
def get_smart_server(self, transport, inet, port):
4493
"""Construct a smart server.
4494
4495
:param transport: The base transport from which branches will be
4496
served.
4497
:param inet: If True, serve over stdin and stdout. Used for running
4498
from inet.
4499
:param port: The port to listen on. By default, it's `
4500
medium.BZR_DEFAULT_PORT`. See `get_host_and_port` for more
4501
information.
4502
:return: A smart server.
4503
"""
4504
from bzrlib.smart import medium, server
4505
if inet:
4506
smart_server = medium.SmartServerPipeStreamMedium(
4507
sys.stdin, sys.stdout, transport)
4508
else:
4509
host, port = self.get_host_and_port(port)
4510
smart_server = server.SmartTCPServer(
4511
transport, host=host, port=port)
4512
note('listening on port: %s' % smart_server.port)
4513
return smart_server
4514
4515
def run(self, port=None, inet=False, directory=None, allow_writes=False):
4516
from bzrlib.transport import get_transport
4517
from bzrlib.transport.chroot import ChrootServer
4907
4518
if directory is None:
4908
4519
directory = os.getcwd()
4909
if protocol is None:
4910
protocol = transport_server_registry.get()
4911
host, port = self.get_host_and_port(port)
4912
4520
url = urlutils.local_path_to_url(directory)
4913
4521
if not allow_writes:
4914
4522
url = 'readonly+' + url
4915
transport = get_transport(url)
4916
protocol(transport, host, port, inet)
4523
chroot_server = ChrootServer(get_transport(url))
4524
chroot_server.setUp()
4525
t = get_transport(chroot_server.get_url())
4526
smart_server = self.get_smart_server(t, inet, port)
4527
self.run_smart_server(smart_server)
4917
4528
4918
4529
4919
4530
class cmd_join(Command):
4920
__doc__ = """Combine a tree into its containing tree.
4531
"""Combine a subtree into its containing tree.
4921
4532
4922
This command requires the target tree to be in a rich-root format.
4533
This command is for experimental use only. It requires the target tree
4534
to be in dirstate-with-subtree format, which cannot be converted into
4535
earlier formats.
4923
4536
4924
4537
The TREE argument should be an independent tree, inside another tree, but
4925
4538
not part of it. (Such trees can be produced by "bzr split", but also by
4928
4541
The result is a combined tree, with the subtree no longer an independant
4929
4542
part. This is marked as a merge of the subtree into the containing tree,
4930
4543
and all history is preserved.
4544
4545
If --reference is specified, the subtree retains its independence. It can
4546
be branched by itself, and can be part of multiple projects at the same
4547
time. But operations performed in the containing tree, such as commit
4548
and merge, will recurse into the subtree.
4931
4549
"""
4932
4550
4933
4551
_see_also = ['split']
4934
4552
takes_args = ['tree']
4935
4553
takes_options = [
4936
Option('reference', help='Join by reference.', hidden=True),
4554
Option('reference', help='Join by reference.'),
4937
4555
]
4556
hidden = True
4938
4557
4939
4558
def run(self, tree, reference=False):
4940
4559
sub_tree = WorkingTree.open(tree)
4963
4582
4964
4583
4965
4584
class cmd_split(Command):
4966
__doc__ = """Split a subdirectory of a tree into a separate tree.
4585
"""Split a subdirectory of a tree into a separate tree.
4967
4586
4968
4587
This command will produce a target tree in a format that supports
4969
4588
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4974
4593
branch. Commits in the top-level tree will not apply to the new subtree.
4975
4594
"""
4976
4595
4977
_see_also = ['join']
4596
# join is not un-hidden yet
4597
#_see_also = ['join']
4978
4598
takes_args = ['tree']
4979
4599
4980
4600
def run(self, tree):
4985
4605
try:
4986
4606
containing_tree.extract(sub_id)
4987
4607
except errors.RootNotRich:
4988
raise errors.RichRootUpgradeRequired(containing_tree.branch.base)
4608
raise errors.UpgradeRequired(containing_tree.branch.base)
4989
4609
4990
4610
4991
4611
class cmd_merge_directive(Command):
4992
__doc__ = """Generate a merge directive for auto-merge tools.
4612
"""Generate a merge directive for auto-merge tools.
4993
4613
4994
4614
A directive requests a merge to be performed, and also provides all the
4995
4615
information necessary to do so. This means it must either include a
5088
4708
5089
4709
5090
4710
class cmd_send(Command):
5091
__doc__ = """Mail or create a merge-directive for submitting changes.
4711
"""Mail or create a merge-directive for submitting changes.
5092
4712
5093
4713
A merge directive provides many things needed for requesting merges:
5094
4714
5100
4720
directly from the merge directive, without retrieving data from a
5101
4721
branch.
5102
4722
5103
`bzr send` creates a compact data set that, when applied using bzr
5104
merge, has the same effect as merging from the source branch.
5105
5106
By default the merge directive is self-contained and can be applied to any
5107
branch containing submit_branch in its ancestory without needing access to
5108
the source branch.
5109
5110
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5111
revisions, but only a structured request to merge from the
5112
public_location. In that case the public_branch is needed and it must be
5113
up-to-date and accessible to the recipient. The public_branch is always
5114
included if known, so that people can check it later.
5115
5116
The submit branch defaults to the parent of the source branch, but can be
5117
overridden. Both submit branch and public branch will be remembered in
5118
branch.conf the first time they are used for a particular branch. The
5119
source branch defaults to that containing the working directory, but can
5120
be changed using --from.
5121
5122
In order to calculate those changes, bzr must analyse the submit branch.
5123
Therefore it is most efficient for the submit branch to be a local mirror.
5124
If a public location is known for the submit_branch, that location is used
5125
in the merge directive.
5126
5127
The default behaviour is to send the merge directive by mail, unless -o is
5128
given, in which case it is sent to a file.
4723
If --no-bundle is specified, then public_branch is needed (and must be
4724
up-to-date), so that the receiver can perform the merge using the
4725
public_branch. The public_branch is always included if known, so that
4726
people can check it later.
4727
4728
The submit branch defaults to the parent, but can be overridden. Both
4729
submit branch and public branch will be remembered if supplied.
4730
4731
If a public_branch is known for the submit_branch, that public submit
4732
branch is used in the merge instructions. This means that a local mirror
4733
can be used as your actual submit branch, once you have set public_branch
4734
for that mirror.
5129
4735
5130
4736
Mail is sent using your preferred mail program. This should be transparent
5131
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
4737
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5132
4738
If the preferred client can't be found (or used), your editor will be used.
5133
4739
5134
4740
To use a specific mail program, set the mail_client configuration option.
5135
4741
(For Thunderbird 1.5, this works around some bugs.) Supported values for
5136
specific clients are "claws", "evolution", "kmail", "mail.app" (MacOS X's
5137
Mail.app), "mutt", and "thunderbird"; generic options are "default",
5138
"editor", "emacsclient", "mapi", and "xdg-email". Plugins may also add
5139
supported clients.
4742
specific clients are "claws", "evolution", "kmail", "mutt", and
4743
"thunderbird"; generic options are "default", "editor", "emacsclient",
4744
"mapi", and "xdg-email". Plugins may also add supported clients.
5140
4745
5141
4746
If mail is being sent, a to address is required. This can be supplied
5142
4747
either on the commandline, by setting the submit_to configuration
5151
4756
5152
4757
The merge directives created by bzr send may be applied using bzr merge or
5153
4758
bzr pull by specifying a file containing a merge directive as the location.
5154
5155
bzr send makes extensive use of public locations to map local locations into
5156
URLs that can be used by other people. See `bzr help configuration` to
5157
set them, and use `bzr info` to display them.
5158
4759
"""
5159
4760
5160
4761
encoding_type = 'exact'
5176
4777
short_name='f',
5177
4778
type=unicode),
5178
4779
Option('output', short_name='o',
5179
help='Write merge directive to this file or directory; '
4780
help='Write merge directive to this file; '
5180
4781
'use - for stdout.',
5181
4782
type=unicode),
5182
Option('strict',
5183
help='Refuse to send if there are uncommitted changes in'
5184
' the working tree, --no-strict disables the check.'),
5185
4783
Option('mail-to', help='Mail the request to this address.',
5186
4784
type=unicode),
5187
4785
'revision',
5188
4786
'message',
5189
4787
Option('body', help='Body for the email.', type=unicode),
5190
RegistryOption('format',
5191
help='Use the specified output format.',
5192
lazy_registry=('bzrlib.send', 'format_registry')),
4788
RegistryOption.from_kwargs('format',
4789
'Use the specified output format.',
4790
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4791
'0.9': 'Bundle format 0.9, Merge Directive 1',})
5193
4792
]
5194
4793
5195
4794
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5196
4795
no_patch=False, revision=None, remember=False, output=None,
5197
format=None, mail_to=None, message=None, body=None,
5198
strict=None, **kwargs):
5199
from bzrlib.send import send
5200
return send(submit_branch, revision, public_branch, remember,
5201
format, no_bundle, no_patch, output,
5202
kwargs.get('from', '.'), mail_to, message, body,
5203
self.outf,
5204
strict=strict)
4796
format='4', mail_to=None, message=None, body=None, **kwargs):
4797
return self._run(submit_branch, revision, public_branch, remember,
4798
format, no_bundle, no_patch, output,
4799
kwargs.get('from', '.'), mail_to, message, body)
4800
4801
def _run(self, submit_branch, revision, public_branch, remember, format,
4802
no_bundle, no_patch, output, from_, mail_to, message, body):
4803
from bzrlib.revision import NULL_REVISION
4804
branch = Branch.open_containing(from_)[0]
4805
if output is None:
4806
outfile = cStringIO.StringIO()
4807
elif output == '-':
4808
outfile = self.outf
4809
else:
4810
outfile = open(output, 'wb')
4811
# we may need to write data into branch's repository to calculate
4812
# the data to send.
4813
branch.lock_write()
4814
try:
4815
if output is None:
4816
config = branch.get_config()
4817
if mail_to is None:
4818
mail_to = config.get_user_option('submit_to')
4819
mail_client = config.get_mail_client()
4820
if (not getattr(mail_client, 'supports_body', False)
4821
and body is not None):
4822
raise errors.BzrCommandError(
4823
'Mail client "%s" does not support specifying body' %
4824
mail_client.__class__.__name__)
4825
if remember and submit_branch is None:
4826
raise errors.BzrCommandError(
4827
'--remember requires a branch to be specified.')
4828
stored_submit_branch = branch.get_submit_branch()
4829
remembered_submit_branch = None
4830
if submit_branch is None:
4831
submit_branch = stored_submit_branch
4832
remembered_submit_branch = "submit"
4833
else:
4834
if stored_submit_branch is None or remember:
4835
branch.set_submit_branch(submit_branch)
4836
if submit_branch is None:
4837
submit_branch = branch.get_parent()
4838
remembered_submit_branch = "parent"
4839
if submit_branch is None:
4840
raise errors.BzrCommandError('No submit branch known or'
4841
' specified')
4842
if remembered_submit_branch is not None:
4843
note('Using saved %s location "%s" to determine what '
4844
'changes to submit.', remembered_submit_branch,
4845
submit_branch)
4846
4847
if mail_to is None:
4848
submit_config = Branch.open(submit_branch).get_config()
4849
mail_to = submit_config.get_user_option("child_submit_to")
4850
4851
stored_public_branch = branch.get_public_branch()
4852
if public_branch is None:
4853
public_branch = stored_public_branch
4854
elif stored_public_branch is None or remember:
4855
branch.set_public_branch(public_branch)
4856
if no_bundle and public_branch is None:
4857
raise errors.BzrCommandError('No public branch specified or'
4858
' known')
4859
base_revision_id = None
4860
revision_id = None
4861
if revision is not None:
4862
if len(revision) > 2:
4863
raise errors.BzrCommandError('bzr send takes '
4864
'at most two one revision identifiers')
4865
revision_id = revision[-1].as_revision_id(branch)
4866
if len(revision) == 2:
4867
base_revision_id = revision[0].as_revision_id(branch)
4868
if revision_id is None:
4869
revision_id = branch.last_revision()
4870
if revision_id == NULL_REVISION:
4871
raise errors.BzrCommandError('No revisions to submit.')
4872
if format == '4':
4873
directive = merge_directive.MergeDirective2.from_objects(
4874
branch.repository, revision_id, time.time(),
4875
osutils.local_time_offset(), submit_branch,
4876
public_branch=public_branch, include_patch=not no_patch,
4877
include_bundle=not no_bundle, message=message,
4878
base_revision_id=base_revision_id)
4879
elif format == '0.9':
4880
if not no_bundle:
4881
if not no_patch:
4882
patch_type = 'bundle'
4883
else:
4884
raise errors.BzrCommandError('Format 0.9 does not'
4885
' permit bundle with no patch')
4886
else:
4887
if not no_patch:
4888
patch_type = 'diff'
4889
else:
4890
patch_type = None
4891
directive = merge_directive.MergeDirective.from_objects(
4892
branch.repository, revision_id, time.time(),
4893
osutils.local_time_offset(), submit_branch,
4894
public_branch=public_branch, patch_type=patch_type,
4895
message=message)
4896
4897
outfile.writelines(directive.to_lines())
4898
if output is None:
4899
subject = '[MERGE] '
4900
if message is not None:
4901
subject += message
4902
else:
4903
revision = branch.repository.get_revision(revision_id)
4904
subject += revision.get_summary()
4905
basename = directive.get_disk_name(branch)
4906
mail_client.compose_merge_request(mail_to, subject,
4907
outfile.getvalue(),
4908
basename, body)
4909
finally:
4910
if output != '-':
4911
outfile.close()
4912
branch.unlock()
5205
4913
5206
4914
5207
4915
class cmd_bundle_revisions(cmd_send):
5208
__doc__ = """Create a merge-directive for submitting changes.
4916
4917
"""Create a merge-directive for submitting changes.
5209
4918
5210
4919
A merge directive provides many things needed for requesting merges:
5211
4920
5251
4960
type=unicode),
5252
4961
Option('output', short_name='o', help='Write directive to this file.',
5253
4962
type=unicode),
5254
Option('strict',
5255
help='Refuse to bundle revisions if there are uncommitted'
5256
' changes in the working tree, --no-strict disables the check.'),
5257
4963
'revision',
5258
RegistryOption('format',
5259
help='Use the specified output format.',
5260
lazy_registry=('bzrlib.send', 'format_registry')),
4964
RegistryOption.from_kwargs('format',
4965
'Use the specified output format.',
4966
**{'4': 'Bundle format 4, Merge Directive 2 (default)',
4967
'0.9': 'Bundle format 0.9, Merge Directive 1',})
5261
4968
]
5262
4969
aliases = ['bundle']
5263
4970
5267
4974
5268
4975
def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5269
4976
no_patch=False, revision=None, remember=False, output=None,
5270
format=None, strict=None, **kwargs):
4977
format='4', **kwargs):
5271
4978
if output is None:
5272
4979
output = '-'
5273
from bzrlib.send import send
5274
return send(submit_branch, revision, public_branch, remember,
4980
return self._run(submit_branch, revision, public_branch, remember,
5275
4981
format, no_bundle, no_patch, output,
5276
kwargs.get('from', '.'), None, None, None,
5277
self.outf, strict=strict)
4982
kwargs.get('from', '.'), None, None, None)
5278
4983
5279
4984
5280
4985
class cmd_tag(Command):
5281
__doc__ = """Create, remove or modify a tag naming a revision.
4986
"""Create, remove or modify a tag naming a revision.
5282
4987
5283
4988
Tags give human-meaningful names to revisions. Commands that take a -r
5284
4989
(--revision) option can be given -rtag:X, where X is any previously
5292
4997
5293
4998
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5294
4999
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5295
5296
If no tag name is specified it will be determined through the
5297
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5298
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5299
details.
5300
5000
"""
5301
5001
5302
5002
_see_also = ['commit', 'tags']
5303
takes_args = ['tag_name?']
5003
takes_args = ['tag_name']
5304
5004
takes_options = [
5305
5005
Option('delete',
5306
5006
help='Delete this tag rather than placing it.',
5307
5007
),
5308
custom_help('directory',
5309
help='Branch in which to place the tag.'),
5008
Option('directory',
5009
help='Branch in which to place the tag.',
5010
short_name='d',
5011
type=unicode,
5012
),
5310
5013
Option('force',
5311
5014
help='Replace existing tags.',
5312
5015
),
5313
5016
'revision',
5314
5017
]
5315
5018
5316
def run(self, tag_name=None,
5019
def run(self, tag_name,
5317
5020
delete=None,
5318
5021
directory='.',
5319
5022
force=None,
5320
5023
revision=None,
5321
5024
):
5322
5025
branch, relpath = Branch.open_containing(directory)
5323
self.add_cleanup(branch.lock_write().unlock)
5324
if delete:
5325
if tag_name is None:
5326
raise errors.BzrCommandError("No tag specified to delete.")
5327
branch.tags.delete_tag(tag_name)
5328
self.outf.write('Deleted tag %s.\n' % tag_name)
5329
else:
5330
if revision:
5331
if len(revision) != 1:
5332
raise errors.BzrCommandError(
5333
"Tags can only be placed on a single revision, "
5334
"not on a range")
5335
revision_id = revision[0].as_revision_id(branch)
5026
branch.lock_write()
5027
try:
5028
if delete:
5029
branch.tags.delete_tag(tag_name)
5030
self.outf.write('Deleted tag %s.\n' % tag_name)
5336
5031
else:
5337
revision_id = branch.last_revision()
5338
if tag_name is None:
5339
tag_name = branch.automatic_tag_name(revision_id)
5340
if tag_name is None:
5341
raise errors.BzrCommandError(
5342
"Please specify a tag name.")
5343
if (not force) and branch.tags.has_tag(tag_name):
5344
raise errors.TagAlreadyExists(tag_name)
5345
branch.tags.set_tag(tag_name, revision_id)
5346
self.outf.write('Created tag %s.\n' % tag_name)
5032
if revision:
5033
if len(revision) != 1:
5034
raise errors.BzrCommandError(
5035
"Tags can only be placed on a single revision, "
5036
"not on a range")
5037
revision_id = revision[0].as_revision_id(branch)
5038
else:
5039
revision_id = branch.last_revision()
5040
if (not force) and branch.tags.has_tag(tag_name):
5041
raise errors.TagAlreadyExists(tag_name)
5042
branch.tags.set_tag(tag_name, revision_id)
5043
self.outf.write('Created tag %s.\n' % tag_name)
5044
finally:
5045
branch.unlock()
5347
5046
5348
5047
5349
5048
class cmd_tags(Command):
5350
__doc__ = """List tags.
5049
"""List tags.
5351
5050
5352
5051
This command shows a table of tag names and the revisions they reference.
5353
5052
"""
5354
5053
5355
5054
_see_also = ['tag']
5356
5055
takes_options = [
5357
custom_help('directory',
5358
help='Branch whose tags should be displayed.'),
5056
Option('directory',
5057
help='Branch whose tags should be displayed.',
5058
short_name='d',
5059
type=unicode,
5060
),
5359
5061
RegistryOption.from_kwargs('sort',
5360
5062
'Sort tags by different criteria.', title='Sorting',
5361
5063
alpha='Sort tags lexicographically (default).',
5378
5080
if not tags:
5379
5081
return
5380
5082
5381
self.add_cleanup(branch.lock_read().unlock)
5382
5083
if revision:
5383
graph = branch.repository.get_graph()
5384
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5385
revid1, revid2 = rev1.rev_id, rev2.rev_id
5386
# only show revisions between revid1 and revid2 (inclusive)
5387
tags = [(tag, revid) for tag, revid in tags if
5388
graph.is_between(revid, revid1, revid2)]
5084
branch.lock_read()
5085
try:
5086
graph = branch.repository.get_graph()
5087
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5088
revid1, revid2 = rev1.rev_id, rev2.rev_id
5089
# only show revisions between revid1 and revid2 (inclusive)
5090
tags = [(tag, revid) for tag, revid in tags if
5091
graph.is_between(revid, revid1, revid2)]
5092
finally:
5093
branch.unlock()
5389
5094
if sort == 'alpha':
5390
5095
tags.sort()
5391
5096
elif sort == 'time':
5401
5106
tags.sort(key=lambda x: timestamps[x[1]])
5402
5107
if not show_ids:
5403
5108
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5404
for index, (tag, revid) in enumerate(tags):
5405
try:
5406
revno = branch.revision_id_to_dotted_revno(revid)
5407
if isinstance(revno, tuple):
5408
revno = '.'.join(map(str, revno))
5409
except errors.NoSuchRevision:
5410
# Bad tag data/merges can lead to tagged revisions
5411
# which are not in this branch. Fail gracefully ...
5412
revno = '?'
5413
tags[index] = (tag, revno)
5414
self.cleanup_now()
5109
revno_map = branch.get_revision_id_to_revno_map()
5110
tags = [ (tag, '.'.join(map(str, revno_map.get(revid, ('?',)))))
5111
for tag, revid in tags ]
5415
5112
for tag, revspec in tags:
5416
5113
self.outf.write('%-20s %s\n' % (tag, revspec))
5417
5114
5418
5115
5419
5116
class cmd_reconfigure(Command):
5420
__doc__ = """Reconfigure the type of a bzr directory.
5117
"""Reconfigure the type of a bzr directory.
5421
5118
5422
5119
A target configuration must be specified.
5423
5120
5453
5150
),
5454
5151
Option('bind-to', help='Branch to bind checkout to.', type=str),
5455
5152
Option('force',
5456
help='Perform reconfiguration even if local changes'
5457
' will be lost.'),
5458
Option('stacked-on',
5459
help='Reconfigure a branch to be stacked on another branch.',
5460
type=unicode,
5461
),
5462
Option('unstacked',
5463
help='Reconfigure a branch to be unstacked. This '
5464
'may require copying substantial data into it.',
5465
),
5153
help='Perform reconfiguration even if local changes'
5154
' will be lost.')
5466
5155
]
5467
5156
5468
def run(self, location=None, target_type=None, bind_to=None, force=False,
5469
stacked_on=None,
5470
unstacked=None):
5157
def run(self, location=None, target_type=None, bind_to=None, force=False):
5471
5158
directory = bzrdir.BzrDir.open(location)
5472
if stacked_on and unstacked:
5473
raise BzrCommandError("Can't use both --stacked-on and --unstacked")
5474
elif stacked_on is not None:
5475
reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5476
elif unstacked:
5477
reconfigure.ReconfigureUnstacked().apply(directory)
5478
# At the moment you can use --stacked-on and a different
5479
# reconfiguration shape at the same time; there seems no good reason
5480
# to ban it.
5481
5159
if target_type is None:
5482
if stacked_on or unstacked:
5483
return
5484
else:
5485
raise errors.BzrCommandError('No target configuration '
5486
'specified')
5160
raise errors.BzrCommandError('No target configuration specified')
5487
5161
elif target_type == 'branch':
5488
5162
reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5489
5163
elif target_type == 'tree':
5508
5182
5509
5183
5510
5184
class cmd_switch(Command):
5511
__doc__ = """Set the branch of a checkout and update.
5185
"""Set the branch of a checkout and update.
5512
5186
5513
5187
For lightweight checkouts, this changes the branch being referenced.
5514
5188
For heavyweight checkouts, this checks that there are no local commits
5526
5200
/path/to/newbranch.
5527
5201
5528
5202
Bound branches use the nickname of its master branch unless it is set
5529
locally, in which case switching will update the local nickname to be
5203
locally, in which case switching will update the the local nickname to be
5530
5204
that of the master.
5531
5205
"""
5532
5206
5533
takes_args = ['to_location?']
5207
takes_args = ['to_location']
5534
5208
takes_options = [Option('force',
5535
help='Switch even if local commits will be lost.'),
5536
'revision',
5537
Option('create-branch', short_name='b',
5538
help='Create the target branch from this one before'
5539
' switching to it.'),
5540
]
5209
help='Switch even if local commits will be lost.')
5210
]
5541
5211
5542
def run(self, to_location=None, force=False, create_branch=False,
5543
revision=None):
5212
def run(self, to_location, force=False):
5544
5213
from bzrlib import switch
5545
5214
tree_location = '.'
5546
revision = _get_one_revision('switch', revision)
5547
5215
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5548
if to_location is None:
5549
if revision is None:
5550
raise errors.BzrCommandError('You must supply either a'
5551
' revision or a location')
5552
to_location = '.'
5216
branch = control_dir.open_branch()
5553
5217
try:
5554
branch = control_dir.open_branch()
5555
had_explicit_nick = branch.get_config().has_explicit_nickname()
5218
to_branch = Branch.open(to_location)
5556
5219
except errors.NotBranchError:
5557
branch = None
5558
had_explicit_nick = False
5559
if create_branch:
5560
if branch is None:
5561
raise errors.BzrCommandError('cannot create branch without'
5562
' source branch')
5563
to_location = directory_service.directories.dereference(
5564
to_location)
5565
if '/' not in to_location and '\\' not in to_location:
5566
# This path is meant to be relative to the existing branch
5567
this_url = self._get_branch_location(control_dir)
5568
to_location = urlutils.join(this_url, '..', to_location)
5569
to_branch = branch.bzrdir.sprout(to_location,
5570
possible_transports=[branch.bzrdir.root_transport],
5571
source_branch=branch).open_branch()
5572
else:
5573
try:
5574
to_branch = Branch.open(to_location)
5575
except errors.NotBranchError:
5576
this_url = self._get_branch_location(control_dir)
5577
to_branch = Branch.open(
5578
urlutils.join(this_url, '..', to_location))
5579
if revision is not None:
5580
revision = revision.as_revision_id(to_branch)
5581
switch.switch(control_dir, to_branch, force, revision_id=revision)
5582
if had_explicit_nick:
5220
this_branch = control_dir.open_branch()
5221
# This may be a heavy checkout, where we want the master branch
5222
this_url = this_branch.get_bound_location()
5223
# If not, use a local sibling
5224
if this_url is None:
5225
this_url = this_branch.base
5226
to_branch = Branch.open(
5227
urlutils.join(this_url, '..', to_location))
5228
switch.switch(control_dir, to_branch, force)
5229
if branch.get_config().has_explicit_nickname():
5583
5230
branch = control_dir.open_branch() #get the new branch!
5584
5231
branch.nick = to_branch.nick
5585
5232
note('Switched to branch: %s',
5586
5233
urlutils.unescape_for_display(to_branch.base, 'utf-8'))
5587
5234
5588
def _get_branch_location(self, control_dir):
5589
"""Return location of branch for this control dir."""
5590
try:
5591
this_branch = control_dir.open_branch()
5592
# This may be a heavy checkout, where we want the master branch
5593
master_location = this_branch.get_bound_location()
5594
if master_location is not None:
5595
return master_location
5596
# If not, use a local sibling
5597
return this_branch.base
5598
except errors.NotBranchError:
5599
format = control_dir.find_branch_format()
5600
if getattr(format, 'get_reference', None) is not None:
5601
return format.get_reference(control_dir)
5602
else:
5603
return control_dir.root_transport.base
5604
5605
5235
5606
5236
class cmd_view(Command):
5607
__doc__ = """Manage filtered views.
5237
"""Manage filtered views.
5608
5238
5609
5239
Views provide a mask over the tree so that users can focus on
5610
5240
a subset of a tree when doing their work. After creating a view,
5758
5388
5759
5389
5760
5390
class cmd_hooks(Command):
5761
__doc__ = """Show hooks."""
5391
"""Show hooks."""
5762
5392
5763
5393
hidden = True
5764
5394
5777
5407
self.outf.write(" <no hooks installed>\n")
5778
5408
5779
5409
5780
class cmd_remove_branch(Command):
5781
__doc__ = """Remove a branch.
5782
5783
This will remove the branch from the specified location but
5784
will keep any working tree or repository in place.
5785
5786
:Examples:
5787
5788
Remove the branch at repo/trunk::
5789
5790
bzr remove-branch repo/trunk
5791
5792
"""
5793
5794
takes_args = ["location?"]
5795
5796
aliases = ["rmbranch"]
5797
5798
def run(self, location=None):
5799
if location is None:
5800
location = "."
5801
branch = Branch.open_containing(location)[0]
5802
branch.bzrdir.destroy_branch()
5803
5804
5805
5410
class cmd_shelve(Command):
5806
__doc__ = """Temporarily set aside some changes from the current tree.
5411
"""Temporarily set aside some changes from the current tree.
5807
5412
5808
5413
Shelve allows you to temporarily put changes you've made "on the shelf",
5809
5414
ie. out of the way, until a later time when you can bring them back from
5851
5456
if writer is None:
5852
5457
writer = bzrlib.option.diff_writer_registry.get()
5853
5458
try:
5854
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5855
file_list, message, destroy=destroy)
5856
try:
5857
shelver.run()
5858
finally:
5859
shelver.finalize()
5459
Shelver.from_args(writer(sys.stdout), revision, all, file_list,
5460
message, destroy=destroy).run()
5860
5461
except errors.UserAbort:
5861
5462
return 0
5862
5463
5863
5464
def run_for_list(self):
5864
5465
tree = WorkingTree.open_containing('.')[0]
5865
self.add_cleanup(tree.lock_read().unlock)
5866
manager = tree.get_shelf_manager()
5867
shelves = manager.active_shelves()
5868
if len(shelves) == 0:
5869
note('No shelved changes.')
5870
return 0
5871
for shelf_id in reversed(shelves):
5872
message = manager.get_metadata(shelf_id).get('message')
5873
if message is None:
5874
message = '<no message>'
5875
self.outf.write('%3d: %s\n' % (shelf_id, message))
5876
return 1
5466
tree.lock_read()
5467
try:
5468
manager = tree.get_shelf_manager()
5469
shelves = manager.active_shelves()
5470
if len(shelves) == 0:
5471
note('No shelved changes.')
5472
return 0
5473
for shelf_id in reversed(shelves):
5474
message = manager.get_metadata(shelf_id).get('message')
5475
if message is None:
5476
message = '<no message>'
5477
self.outf.write('%3d: %s\n' % (shelf_id, message))
5478
return 1
5479
finally:
5480
tree.unlock()
5877
5481
5878
5482
5879
5483
class cmd_unshelve(Command):
5880
__doc__ = """Restore shelved changes.
5484
"""Restore shelved changes.
5881
5485
5882
5486
By default, the most recently shelved changes are restored. However if you
5883
5487
specify a shelf by id those changes will be restored instead. This works
5891
5495
enum_switch=False, value_switches=True,
5892
5496
apply="Apply changes and remove from the shelf.",
5893
5497
dry_run="Show changes, but do not apply or remove them.",
5894
preview="Instead of unshelving the changes, show the diff that "
5895
"would result from unshelving.",
5896
delete_only="Delete changes without applying them.",
5897
keep="Apply changes but don't delete them.",
5498
delete_only="Delete changes without applying them."
5898
5499
)
5899
5500
]
5900
5501
_see_also = ['shelve']
5901
5502
5902
5503
def run(self, shelf_id=None, action='apply'):
5903
5504
from bzrlib.shelf_ui import Unshelver
5904
unshelver = Unshelver.from_args(shelf_id, action)
5905
try:
5906
unshelver.run()
5907
finally:
5908
unshelver.tree.unlock()
5505
Unshelver.from_args(shelf_id, action).run()
5909
5506
5910
5507
5911
5508
class cmd_clean_tree(Command):
5912
__doc__ = """Remove unwanted files from working tree.
5509
"""Remove unwanted files from working tree.
5913
5510
5914
5511
By default, only unknown files, not ignored files, are deleted. Versioned
5915
5512
files are never deleted.
5923
5520
5924
5521
To check what clean-tree will do, use --dry-run.
5925
5522
"""
5926
takes_options = ['directory',
5927
Option('ignored', help='Delete all ignored files.'),
5523
takes_options = [Option('ignored', help='Delete all ignored files.'),
5928
5524
Option('detritus', help='Delete conflict files, merge'
5929
5525
' backups, and failed selftest dirs.'),
5930
5526
Option('unknown',
5933
5529
' deleting them.'),
5934
5530
Option('force', help='Do not prompt before deleting.')]
5935
5531
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5936
force=False, directory=u'.'):
5532
force=False):
5937
5533
from bzrlib.clean_tree import clean_tree
5938
5534
if not (unknown or ignored or detritus):
5939
5535
unknown = True
5940
5536
if dry_run:
5941
5537
force = True
5942
clean_tree(directory, unknown=unknown, ignored=ignored,
5943
detritus=detritus, dry_run=dry_run, no_prompt=force)
5944
5945
5946
class cmd_reference(Command):
5947
__doc__ = """list, view and set branch locations for nested trees.
5948
5949
If no arguments are provided, lists the branch locations for nested trees.
5950
If one argument is provided, display the branch location for that tree.
5951
If two arguments are provided, set the branch location for that tree.
5952
"""
5953
5954
hidden = True
5955
5956
takes_args = ['path?', 'location?']
5957
5958
def run(self, path=None, location=None):
5959
branchdir = '.'
5960
if path is not None:
5961
branchdir = path
5962
tree, branch, relpath =(
5963
bzrdir.BzrDir.open_containing_tree_or_branch(branchdir))
5964
if path is not None:
5965
path = relpath
5966
if tree is None:
5967
tree = branch.basis_tree()
5968
if path is None:
5969
info = branch._get_all_reference_info().iteritems()
5970
self._display_reference_info(tree, branch, info)
5538
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5539
dry_run=dry_run, no_prompt=force)
5540
5541
5542
def _create_prefix(cur_transport):
5543
needed = [cur_transport]
5544
# Recurse upwards until we can create a directory successfully
5545
while True:
5546
new_transport = cur_transport.clone('..')
5547
if new_transport.base == cur_transport.base:
5548
raise errors.BzrCommandError(
5549
"Failed to create path prefix for %s."
5550
% cur_transport.base)
5551
try:
5552
new_transport.mkdir('.')
5553
except errors.NoSuchFile:
5554
needed.append(new_transport)
5555
cur_transport = new_transport
5971
5556
else:
5972
file_id = tree.path2id(path)
5973
if file_id is None:
5974
raise errors.NotVersionedError(path)
5975
if location is None:
5976
info = [(file_id, branch.get_reference_info(file_id))]
5977
self._display_reference_info(tree, branch, info)
5978
else:
5979
branch.set_reference_info(file_id, path, location)
5980
5981
def _display_reference_info(self, tree, branch, info):
5982
ref_list = []
5983
for file_id, (path, location) in info:
5984
try:
5985
path = tree.id2path(file_id)
5986
except errors.NoSuchId:
5987
pass
5988
ref_list.append((path, location))
5989
for path, location in sorted(ref_list):
5990
self.outf.write('%s %s\n' % (path, location))
5991
5992
5993
def _register_lazy_builtins():
5994
# register lazy builtins from other modules; called at startup and should
5995
# be only called once.
5996
for (name, aliases, module_name) in [
5997
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
5998
('cmd_dpush', [], 'bzrlib.foreign'),
5999
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6000
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6001
('cmd_conflicts', [], 'bzrlib.conflicts'),
6002
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6003
]:
6004
builtin_command_registry.register_lazy(name, aliases, module_name)
5557
break
5558
# Now we only need to create child directories
5559
while needed:
5560
cur_transport = needed.pop()
5561
cur_transport.ensure_base()
5562
5563
5564
# these get imported and then picked up by the scan for cmd_*
5565
# TODO: Some more consistent way to split command definitions across files;
5566
# we do need to load at least some information about them to know of
5567
# aliases. ideally we would avoid loading the implementation until the
5568
# details were needed.
5569
from bzrlib.cmd_version_info import cmd_version_info
5570
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5571
from bzrlib.bundle.commands import (
5572
cmd_bundle_info,
5573
)
5574
from bzrlib.sign_my_commits import cmd_sign_my_commits
5575
from bzrlib.weave_commands import cmd_versionedfile_list, \
5576
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0