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 4908
- compare with another revision
- download diff
- download tarball
- view history from revision 4908
- Committer: Canonical.com Patch Queue Manager
- Date: 2009-12-18 10:09:49 UTC
- mfrom: (4871.5.4 admin-guide-submit)
- Revision ID: pqm@pqm.ubuntu.com-20091218100949-2c1ityvnbqjtdf3g
(nmb) Add backup section to admin-guide
- files added:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- 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
- contrib/debian
- doc/en/whats-new
- files renamed:
- bzrlib/help_topics/en/conflict-types.txt => bzrlib/help_topics/en/conflicts.txt
- bzrlib/tests/test__bencode.py => bzrlib/tests/test_bencode.py
- bzrlib/help_topics/es/conflict-types.txt => doc/es/user-guide/resolving_conflicts.txt
- 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,
54
53
)
55
54
from bzrlib.branch import Branch
56
55
from bzrlib.conflicts import ConflictList
57
from bzrlib.transport import memory
58
56
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
59
57
from bzrlib.smtp_connection import SMTPConnection
60
58
from bzrlib.workingtree import WorkingTree
61
59
""")
62
60
63
from bzrlib.commands import (
64
Command,
65
builtin_command_registry,
66
display_command,
67
)
61
from bzrlib.commands import Command, display_command
68
62
from bzrlib.option import (
69
63
ListOption,
70
64
Option,
180
174
view_str = views.view_display_str(view_files)
181
175
note("Ignoring files outside view. View is %s" % view_str)
182
176
return tree, file_list
183
tree = WorkingTree.open_containing(file_list[0])[0]
177
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
178
return tree, safe_relpath_files(tree, file_list, canonicalize,
185
179
apply_view=apply_view)
186
180
232
226
return view_info
233
227
234
228
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
229
# TODO: Make sure no commands unconditionally use the working directory as a
244
230
# branch. If a filename argument is used, the first of them should be used to
245
231
# specify the branch. (Perhaps this can be factored out into some kind of
247
233
# opens the branch?)
248
234
249
235
class cmd_status(Command):
250
__doc__ = """Display status summary.
236
"""Display status summary.
251
237
252
238
This reports on versioned and unknown files, reporting them
253
239
grouped by state. Possible states are:
340
326
341
327
342
328
class cmd_cat_revision(Command):
343
__doc__ = """Write out metadata for a revision.
329
"""Write out metadata for a revision.
344
330
345
331
The revision to print can either be specified by a specific
346
332
revision identifier, or you can use --revision.
348
334
349
335
hidden = True
350
336
takes_args = ['revision_id?']
351
takes_options = ['directory', 'revision']
337
takes_options = ['revision']
352
338
# cat-revision is more for frontends so should be exact
353
339
encoding = 'strict'
354
340
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
341
@display_command
364
def run(self, revision_id=None, revision=None, directory=u'.'):
342
def run(self, revision_id=None, revision=None):
365
343
if revision_id is not None and revision is not None:
366
344
raise errors.BzrCommandError('You can only supply one of'
367
345
' revision_id or --revision')
368
346
if revision_id is None and revision is None:
369
347
raise errors.BzrCommandError('You must supply either'
370
348
' --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
349
b = WorkingTree.open_containing(u'.')[0].branch
350
351
# TODO: jam 20060112 should cat-revision always output utf-8?
352
if revision_id is not None:
353
revision_id = osutils.safe_revision_id(revision_id, warn=False)
354
try:
355
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
356
except errors.NoSuchRevision:
357
msg = "The repository %s contains no revision %s." % (b.repository.base,
358
revision_id)
359
raise errors.BzrCommandError(msg)
360
elif revision is not None:
361
for rev in revision:
362
if rev is None:
363
raise errors.BzrCommandError('You cannot specify a NULL'
364
' revision.')
365
rev_id = rev.as_revision_id(b)
366
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
367
399
368
400
369
class cmd_dump_btree(Command):
401
__doc__ = """Dump the contents of a btree index file to stdout.
370
"""Dump the contents of a btree index file to stdout.
402
371
403
372
PATH is a btree index file, it can be any URL. This includes things like
404
373
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
468
437
for node in bt.iter_all_entries():
469
438
# Node is made up of:
470
439
# (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)
440
refs_as_tuples = static_tuple.as_tuples(node[3])
477
441
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
478
442
self.outf.write('%s\n' % (as_tuple,))
479
443
480
444
481
445
class cmd_remove_tree(Command):
482
__doc__ = """Remove the working tree from a given branch/checkout.
446
"""Remove the working tree from a given branch/checkout.
483
447
484
448
Since a lightweight checkout is little more than a working tree
485
449
this will refuse to run against one.
487
451
To re-create the working tree, use "bzr checkout".
488
452
"""
489
453
_see_also = ['checkout', 'working-trees']
490
takes_args = ['location*']
454
takes_args = ['location?']
491
455
takes_options = [
492
456
Option('force',
493
457
help='Remove the working tree even if it has '
494
'uncommitted or shelved changes.'),
458
'uncommitted changes.'),
495
459
]
496
460
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
if working.get_shelf_manager().last_shelf() is not None:
515
raise errors.ShelvedChanges(working)
516
517
if working.user_url != working.branch.user_url:
518
raise errors.BzrCommandError("You cannot remove the working tree"
519
" from a lightweight checkout")
520
521
d.destroy_workingtree()
461
def run(self, location='.', force=False):
462
d = bzrdir.BzrDir.open(location)
463
464
try:
465
working = d.open_workingtree()
466
except errors.NoWorkingTree:
467
raise errors.BzrCommandError("No working tree to remove")
468
except errors.NotLocalUrl:
469
raise errors.BzrCommandError("You cannot remove the working tree"
470
" of a remote path")
471
if not force:
472
if (working.has_changes()):
473
raise errors.UncommittedChanges(working)
474
475
working_path = working.bzrdir.root_transport.base
476
branch_path = working.branch.bzrdir.root_transport.base
477
if working_path != branch_path:
478
raise errors.BzrCommandError("You cannot remove the working tree"
479
" from a lightweight checkout")
480
481
d.destroy_workingtree()
522
482
523
483
524
484
class cmd_revno(Command):
525
__doc__ = """Show current revision number.
485
"""Show current revision number.
526
486
527
487
This is equal to the number of revisions on this branch.
528
488
"""
538
498
if tree:
539
499
try:
540
500
wt = WorkingTree.open_containing(location)[0]
541
self.add_cleanup(wt.lock_read().unlock)
501
wt.lock_read()
542
502
except (errors.NoWorkingTree, errors.NotLocalUrl):
543
503
raise errors.NoWorkingTree(location)
544
revid = wt.last_revision()
545
504
try:
546
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
547
except errors.NoSuchRevision:
548
revno_t = ('???',)
549
revno = ".".join(str(n) for n in revno_t)
505
revid = wt.last_revision()
506
try:
507
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
508
except errors.NoSuchRevision:
509
revno_t = ('???',)
510
revno = ".".join(str(n) for n in revno_t)
511
finally:
512
wt.unlock()
550
513
else:
551
514
b = Branch.open_containing(location)[0]
552
self.add_cleanup(b.lock_read().unlock)
553
revno = b.revno()
554
self.cleanup_now()
515
b.lock_read()
516
try:
517
revno = b.revno()
518
finally:
519
b.unlock()
520
555
521
self.outf.write(str(revno) + '\n')
556
522
557
523
558
524
class cmd_revision_info(Command):
559
__doc__ = """Show revision number and revision id for a given revision identifier.
525
"""Show revision number and revision id for a given revision identifier.
560
526
"""
561
527
hidden = True
562
528
takes_args = ['revision_info*']
563
529
takes_options = [
564
530
'revision',
565
custom_help('directory',
531
Option('directory',
566
532
help='Branch to examine, '
567
'rather than the one containing the working directory.'),
533
'rather than the one containing the working directory.',
534
short_name='d',
535
type=unicode,
536
),
568
537
Option('tree', help='Show revno of working tree'),
569
538
]
570
539
575
544
try:
576
545
wt = WorkingTree.open_containing(directory)[0]
577
546
b = wt.branch
578
self.add_cleanup(wt.lock_read().unlock)
547
wt.lock_read()
579
548
except (errors.NoWorkingTree, errors.NotLocalUrl):
580
549
wt = None
581
550
b = Branch.open_containing(directory)[0]
582
self.add_cleanup(b.lock_read().unlock)
583
revision_ids = []
584
if revision is not None:
585
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
586
if revision_info_list is not None:
587
for rev_str in revision_info_list:
588
rev_spec = RevisionSpec.from_string(rev_str)
589
revision_ids.append(rev_spec.as_revision_id(b))
590
# No arguments supplied, default to the last revision
591
if len(revision_ids) == 0:
592
if tree:
593
if wt is None:
594
raise errors.NoWorkingTree(directory)
595
revision_ids.append(wt.last_revision())
551
b.lock_read()
552
try:
553
revision_ids = []
554
if revision is not None:
555
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
556
if revision_info_list is not None:
557
for rev_str in revision_info_list:
558
rev_spec = RevisionSpec.from_string(rev_str)
559
revision_ids.append(rev_spec.as_revision_id(b))
560
# No arguments supplied, default to the last revision
561
if len(revision_ids) == 0:
562
if tree:
563
if wt is None:
564
raise errors.NoWorkingTree(directory)
565
revision_ids.append(wt.last_revision())
566
else:
567
revision_ids.append(b.last_revision())
568
569
revinfos = []
570
maxlen = 0
571
for revision_id in revision_ids:
572
try:
573
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
574
revno = '.'.join(str(i) for i in dotted_revno)
575
except errors.NoSuchRevision:
576
revno = '???'
577
maxlen = max(maxlen, len(revno))
578
revinfos.append([revno, revision_id])
579
finally:
580
if wt is None:
581
b.unlock()
596
582
else:
597
revision_ids.append(b.last_revision())
598
599
revinfos = []
600
maxlen = 0
601
for revision_id in revision_ids:
602
try:
603
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
604
revno = '.'.join(str(i) for i in dotted_revno)
605
except errors.NoSuchRevision:
606
revno = '???'
607
maxlen = max(maxlen, len(revno))
608
revinfos.append([revno, revision_id])
609
610
self.cleanup_now()
583
wt.unlock()
584
611
585
for ri in revinfos:
612
586
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
613
587
614
588
615
589
class cmd_add(Command):
616
__doc__ = """Add specified files or directories.
590
"""Add specified files or directories.
617
591
618
592
In non-recursive mode, all the named items are added, regardless
619
593
of whether they were previously ignored. A warning is given if
684
658
should_print=(not is_quiet()))
685
659
686
660
if base_tree:
687
self.add_cleanup(base_tree.lock_read().unlock)
688
tree, file_list = tree_files_for_add(file_list)
689
added, ignored = tree.smart_add(file_list, not
690
no_recurse, action=action, save=not dry_run)
691
self.cleanup_now()
661
base_tree.lock_read()
662
try:
663
tree, file_list = tree_files_for_add(file_list)
664
added, ignored = tree.smart_add(file_list, not
665
no_recurse, action=action, save=not dry_run)
666
finally:
667
if base_tree is not None:
668
base_tree.unlock()
692
669
if len(ignored) > 0:
693
670
if verbose:
694
671
for glob in sorted(ignored.keys()):
698
675
699
676
700
677
class cmd_mkdir(Command):
701
__doc__ = """Create a new versioned directory.
678
"""Create a new versioned directory.
702
679
703
680
This is equivalent to creating the directory and then adding it.
704
681
"""
708
685
709
686
def run(self, dir_list):
710
687
for d in dir_list:
688
os.mkdir(d)
711
689
wt, dd = WorkingTree.open_containing(d)
712
base = os.path.dirname(dd)
713
id = wt.path2id(base)
714
if id != None:
715
os.mkdir(d)
716
wt.add([dd])
717
self.outf.write('added %s\n' % d)
718
else:
719
raise errors.NotVersionedError(path=base)
690
wt.add([dd])
691
self.outf.write('added %s\n' % d)
720
692
721
693
722
694
class cmd_relpath(Command):
723
__doc__ = """Show path of a file relative to root"""
695
"""Show path of a file relative to root"""
724
696
725
697
takes_args = ['filename']
726
698
hidden = True
735
707
736
708
737
709
class cmd_inventory(Command):
738
__doc__ = """Show inventory of the current working copy or a revision.
710
"""Show inventory of the current working copy or a revision.
739
711
740
712
It is possible to limit the output to a particular entry
741
713
type using the --kind option. For example: --kind file.
762
734
763
735
revision = _get_one_revision('inventory', revision)
764
736
work_tree, file_list = tree_files(file_list)
765
self.add_cleanup(work_tree.lock_read().unlock)
766
if revision is not None:
767
tree = revision.as_tree(work_tree.branch)
768
769
extra_trees = [work_tree]
770
self.add_cleanup(tree.lock_read().unlock)
771
else:
772
tree = work_tree
773
extra_trees = []
774
775
if file_list is not None:
776
file_ids = tree.paths2ids(file_list, trees=extra_trees,
777
require_versioned=True)
778
# find_ids_across_trees may include some paths that don't
779
# exist in 'tree'.
780
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
781
for file_id in file_ids if file_id in tree)
782
else:
783
entries = tree.inventory.entries()
784
785
self.cleanup_now()
737
work_tree.lock_read()
738
try:
739
if revision is not None:
740
tree = revision.as_tree(work_tree.branch)
741
742
extra_trees = [work_tree]
743
tree.lock_read()
744
else:
745
tree = work_tree
746
extra_trees = []
747
748
if file_list is not None:
749
file_ids = tree.paths2ids(file_list, trees=extra_trees,
750
require_versioned=True)
751
# find_ids_across_trees may include some paths that don't
752
# exist in 'tree'.
753
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
754
for file_id in file_ids if file_id in tree)
755
else:
756
entries = tree.inventory.entries()
757
finally:
758
tree.unlock()
759
if tree is not work_tree:
760
work_tree.unlock()
761
786
762
for path, entry in entries:
787
763
if kind and kind != entry.kind:
788
764
continue
794
770
795
771
796
772
class cmd_mv(Command):
797
__doc__ = """Move or rename a file.
773
"""Move or rename a file.
798
774
799
775
:Usage:
800
776
bzr mv OLDNAME NEWNAME
833
809
if len(names_list) < 2:
834
810
raise errors.BzrCommandError("missing file argument")
835
811
tree, rel_names = tree_files(names_list, canonicalize=False)
836
self.add_cleanup(tree.lock_tree_write().unlock)
837
self._run(tree, names_list, rel_names, after)
812
tree.lock_tree_write()
813
try:
814
self._run(tree, names_list, rel_names, after)
815
finally:
816
tree.unlock()
838
817
839
818
def run_auto(self, names_list, after, dry_run):
840
819
if names_list is not None and len(names_list) > 1:
844
823
raise errors.BzrCommandError('--after cannot be specified with'
845
824
' --auto.')
846
825
work_tree, file_list = tree_files(names_list, default_branch='.')
847
self.add_cleanup(work_tree.lock_tree_write().unlock)
848
rename_map.RenameMap.guess_renames(work_tree, dry_run)
826
work_tree.lock_tree_write()
827
try:
828
rename_map.RenameMap.guess_renames(work_tree, dry_run)
829
finally:
830
work_tree.unlock()
849
831
850
832
def _run(self, tree, names_list, rel_names, after):
851
833
into_existing = osutils.isdir(names_list[-1])
929
911
930
912
931
913
class cmd_pull(Command):
932
__doc__ = """Turn this branch into a mirror of another branch.
914
"""Turn this branch into a mirror of another branch.
933
915
934
916
By default, this command only works on branches that have not diverged.
935
917
Branches are considered diverged if the destination branch's most recent
958
940
takes_options = ['remember', 'overwrite', 'revision',
959
941
custom_help('verbose',
960
942
help='Show logs of pulled revisions.'),
961
custom_help('directory',
943
Option('directory',
962
944
help='Branch to pull into, '
963
'rather than the one containing the working directory.'),
945
'rather than the one containing the working directory.',
946
short_name='d',
947
type=unicode,
948
),
964
949
Option('local',
965
950
help="Perform a local pull in a bound "
966
951
"branch. Local pulls are not applied to "
981
966
try:
982
967
tree_to = WorkingTree.open_containing(directory)[0]
983
968
branch_to = tree_to.branch
984
self.add_cleanup(tree_to.lock_write().unlock)
985
969
except errors.NoWorkingTree:
986
970
tree_to = None
987
971
branch_to = Branch.open_containing(directory)[0]
988
self.add_cleanup(branch_to.lock_write().unlock)
989
972
990
973
if local and not branch_to.get_bound_location():
991
974
raise errors.LocalRequiresBoundBranch()
992
975
1022
1005
else:
1023
1006
branch_from = Branch.open(location,
1024
1007
possible_transports=possible_transports)
1025
self.add_cleanup(branch_from.lock_read().unlock)
1026
1008
1027
1009
if branch_to.get_parent() is None or remember:
1028
1010
branch_to.set_parent(branch_from.base)
1029
1011
1030
if revision is not None:
1031
revision_id = revision.as_revision_id(branch_from)
1032
1033
if tree_to is not None:
1034
view_info = _get_view_info_for_change_reporter(tree_to)
1035
change_reporter = delta._ChangeReporter(
1036
unversioned_filter=tree_to.is_ignored,
1037
view_info=view_info)
1038
result = tree_to.pull(
1039
branch_from, overwrite, revision_id, change_reporter,
1040
possible_transports=possible_transports, local=local)
1041
else:
1042
result = branch_to.pull(
1043
branch_from, overwrite, revision_id, local=local)
1044
1045
result.report(self.outf)
1046
if verbose and result.old_revid != result.new_revid:
1047
log.show_branch_change(
1048
branch_to, self.outf, result.old_revno,
1049
result.old_revid)
1012
if branch_from is not branch_to:
1013
branch_from.lock_read()
1014
try:
1015
if revision is not None:
1016
revision_id = revision.as_revision_id(branch_from)
1017
1018
branch_to.lock_write()
1019
try:
1020
if tree_to is not None:
1021
view_info = _get_view_info_for_change_reporter(tree_to)
1022
change_reporter = delta._ChangeReporter(
1023
unversioned_filter=tree_to.is_ignored,
1024
view_info=view_info)
1025
result = tree_to.pull(
1026
branch_from, overwrite, revision_id, change_reporter,
1027
possible_transports=possible_transports, local=local)
1028
else:
1029
result = branch_to.pull(
1030
branch_from, overwrite, revision_id, local=local)
1031
1032
result.report(self.outf)
1033
if verbose and result.old_revid != result.new_revid:
1034
log.show_branch_change(
1035
branch_to, self.outf, result.old_revno,
1036
result.old_revid)
1037
finally:
1038
branch_to.unlock()
1039
finally:
1040
if branch_from is not branch_to:
1041
branch_from.unlock()
1050
1042
1051
1043
1052
1044
class cmd_push(Command):
1053
__doc__ = """Update a mirror of this branch.
1045
"""Update a mirror of this branch.
1054
1046
1055
1047
The target branch will not have its working tree populated because this
1056
1048
is both expensive, and is not supported on remote file systems.
1080
1072
Option('create-prefix',
1081
1073
help='Create the path leading up to the branch '
1082
1074
'if it does not already exist.'),
1083
custom_help('directory',
1075
Option('directory',
1084
1076
help='Branch to push from, '
1085
'rather than the one containing the working directory.'),
1077
'rather than the one containing the working directory.',
1078
short_name='d',
1079
type=unicode,
1080
),
1086
1081
Option('use-existing-dir',
1087
1082
help='By default push will fail if the target'
1088
1083
' directory exists, but does not already'
1114
1109
# Get the source branch
1115
1110
(tree, br_from,
1116
1111
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1112
if strict is None:
1113
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1114
if strict is None: strict = True # default value
1117
1115
# Get the tip's revision_id
1118
1116
revision = _get_one_revision('push', revision)
1119
1117
if revision is not None:
1120
1118
revision_id = revision.in_history(br_from).rev_id
1121
1119
else:
1122
1120
revision_id = None
1123
if tree is not None and revision_id is None:
1124
tree.check_changed_or_out_of_date(
1125
strict, 'push_strict',
1126
more_error='Use --no-strict to force the push.',
1127
more_warning='Uncommitted changes will not be pushed.')
1121
if strict and tree is not None and revision_id is None:
1122
if (tree.has_changes()):
1123
raise errors.UncommittedChanges(
1124
tree, more='Use --no-strict to force the push.')
1125
if tree.last_revision() != tree.branch.last_revision():
1126
# The tree has lost sync with its branch, there is little
1127
# chance that the user is aware of it but he can still force
1128
# the push with --no-strict
1129
raise errors.OutOfDateTree(
1130
tree, more='Use --no-strict to force the push.')
1131
1128
1132
# Get the stacked_on branch, if any
1129
1133
if stacked_on is not None:
1130
1134
stacked_on = urlutils.normalize_url(stacked_on)
1162
1166
1163
1167
1164
1168
class cmd_branch(Command):
1165
__doc__ = """Create a new branch that is a copy of an existing branch.
1169
"""Create a new branch that is a copy of an existing branch.
1166
1170
1167
1171
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1168
1172
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1195
1199
' directory exists, but does not already'
1196
1200
' have a control directory. This flag will'
1197
1201
' allow branch to proceed.'),
1198
Option('bind',
1199
help="Bind new branch to from location."),
1200
1202
]
1201
1203
aliases = ['get', 'clone']
1202
1204
1203
1205
def run(self, from_location, to_location=None, revision=None,
1204
1206
hardlink=False, stacked=False, standalone=False, no_tree=False,
1205
use_existing_dir=False, switch=False, bind=False):
1207
use_existing_dir=False, switch=False):
1206
1208
from bzrlib import switch as _mod_switch
1207
1209
from bzrlib.tag import _merge_tags_if_possible
1208
1210
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1209
1211
from_location)
1210
1212
revision = _get_one_revision('branch', revision)
1211
self.add_cleanup(br_from.lock_read().unlock)
1212
if revision is not None:
1213
revision_id = revision.as_revision_id(br_from)
1214
else:
1215
# FIXME - wt.last_revision, fallback to branch, fall back to
1216
# None or perhaps NULL_REVISION to mean copy nothing
1217
# RBC 20060209
1218
revision_id = br_from.last_revision()
1219
if to_location is None:
1220
to_location = urlutils.derive_to_location(from_location)
1221
to_transport = transport.get_transport(to_location)
1213
br_from.lock_read()
1222
1214
try:
1223
to_transport.mkdir('.')
1224
except errors.FileExists:
1225
if not use_existing_dir:
1226
raise errors.BzrCommandError('Target directory "%s" '
1227
'already exists.' % to_location)
1215
if revision is not None:
1216
revision_id = revision.as_revision_id(br_from)
1228
1217
else:
1229
try:
1230
bzrdir.BzrDir.open_from_transport(to_transport)
1231
except errors.NotBranchError:
1232
pass
1218
# FIXME - wt.last_revision, fallback to branch, fall back to
1219
# None or perhaps NULL_REVISION to mean copy nothing
1220
# RBC 20060209
1221
revision_id = br_from.last_revision()
1222
if to_location is None:
1223
to_location = urlutils.derive_to_location(from_location)
1224
to_transport = transport.get_transport(to_location)
1225
try:
1226
to_transport.mkdir('.')
1227
except errors.FileExists:
1228
if not use_existing_dir:
1229
raise errors.BzrCommandError('Target directory "%s" '
1230
'already exists.' % to_location)
1233
1231
else:
1234
raise errors.AlreadyBranchError(to_location)
1235
except errors.NoSuchFile:
1236
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1237
% to_location)
1238
try:
1239
# preserve whatever source format we have.
1240
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1241
possible_transports=[to_transport],
1242
accelerator_tree=accelerator_tree,
1243
hardlink=hardlink, stacked=stacked,
1244
force_new_repo=standalone,
1245
create_tree_if_local=not no_tree,
1246
source_branch=br_from)
1247
branch = dir.open_branch()
1248
except errors.NoSuchRevision:
1249
to_transport.delete_tree('.')
1250
msg = "The branch %s has no revision %s." % (from_location,
1251
revision)
1252
raise errors.BzrCommandError(msg)
1253
_merge_tags_if_possible(br_from, branch)
1254
# If the source branch is stacked, the new branch may
1255
# be stacked whether we asked for that explicitly or not.
1256
# We therefore need a try/except here and not just 'if stacked:'
1257
try:
1258
note('Created new stacked branch referring to %s.' %
1259
branch.get_stacked_on_url())
1260
except (errors.NotStacked, errors.UnstackableBranchFormat,
1261
errors.UnstackableRepositoryFormat), e:
1262
note('Branched %d revision(s).' % branch.revno())
1263
if bind:
1264
# Bind to the parent
1265
parent_branch = Branch.open(from_location)
1266
branch.bind(parent_branch)
1267
note('New branch bound to %s' % from_location)
1268
if switch:
1269
# Switch to the new branch
1270
wt, _ = WorkingTree.open_containing('.')
1271
_mod_switch.switch(wt.bzrdir, branch)
1272
note('Switched to branch: %s',
1273
urlutils.unescape_for_display(branch.base, 'utf-8'))
1232
try:
1233
bzrdir.BzrDir.open_from_transport(to_transport)
1234
except errors.NotBranchError:
1235
pass
1236
else:
1237
raise errors.AlreadyBranchError(to_location)
1238
except errors.NoSuchFile:
1239
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1240
% to_location)
1241
try:
1242
# preserve whatever source format we have.
1243
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1244
possible_transports=[to_transport],
1245
accelerator_tree=accelerator_tree,
1246
hardlink=hardlink, stacked=stacked,
1247
force_new_repo=standalone,
1248
create_tree_if_local=not no_tree,
1249
source_branch=br_from)
1250
branch = dir.open_branch()
1251
except errors.NoSuchRevision:
1252
to_transport.delete_tree('.')
1253
msg = "The branch %s has no revision %s." % (from_location,
1254
revision)
1255
raise errors.BzrCommandError(msg)
1256
_merge_tags_if_possible(br_from, branch)
1257
# If the source branch is stacked, the new branch may
1258
# be stacked whether we asked for that explicitly or not.
1259
# We therefore need a try/except here and not just 'if stacked:'
1260
try:
1261
note('Created new stacked branch referring to %s.' %
1262
branch.get_stacked_on_url())
1263
except (errors.NotStacked, errors.UnstackableBranchFormat,
1264
errors.UnstackableRepositoryFormat), e:
1265
note('Branched %d revision(s).' % branch.revno())
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'))
1272
finally:
1273
br_from.unlock()
1274
1274
1275
1275
1276
1276
class cmd_checkout(Command):
1277
__doc__ = """Create a new checkout of an existing branch.
1277
"""Create a new checkout of an existing branch.
1278
1278
1279
1279
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1280
1280
the branch found in '.'. This is useful if you have removed the working tree
1343
1343
1344
1344
1345
1345
class cmd_renames(Command):
1346
__doc__ = """Show list of renamed files.
1346
"""Show list of renamed files.
1347
1347
"""
1348
1348
# TODO: Option to show renames between two historical versions.
1349
1349
1354
1354
@display_command
1355
1355
def run(self, dir=u'.'):
1356
1356
tree = WorkingTree.open_containing(dir)[0]
1357
self.add_cleanup(tree.lock_read().unlock)
1358
new_inv = tree.inventory
1359
old_tree = tree.basis_tree()
1360
self.add_cleanup(old_tree.lock_read().unlock)
1361
old_inv = old_tree.inventory
1362
renames = []
1363
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1364
for f, paths, c, v, p, n, k, e in iterator:
1365
if paths[0] == paths[1]:
1366
continue
1367
if None in (paths):
1368
continue
1369
renames.append(paths)
1370
renames.sort()
1371
for old_name, new_name in renames:
1372
self.outf.write("%s => %s\n" % (old_name, new_name))
1357
tree.lock_read()
1358
try:
1359
new_inv = tree.inventory
1360
old_tree = tree.basis_tree()
1361
old_tree.lock_read()
1362
try:
1363
old_inv = old_tree.inventory
1364
renames = []
1365
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1366
for f, paths, c, v, p, n, k, e in iterator:
1367
if paths[0] == paths[1]:
1368
continue
1369
if None in (paths):
1370
continue
1371
renames.append(paths)
1372
renames.sort()
1373
for old_name, new_name in renames:
1374
self.outf.write("%s => %s\n" % (old_name, new_name))
1375
finally:
1376
old_tree.unlock()
1377
finally:
1378
tree.unlock()
1373
1379
1374
1380
1375
1381
class cmd_update(Command):
1376
__doc__ = """Update a tree to have the latest code committed to its branch.
1382
"""Update a tree to have the latest code committed to its branch.
1377
1383
1378
1384
This will perform a merge into the working tree, and may generate
1379
1385
conflicts. If you have any local changes, you will still
1381
1387
1382
1388
If you want to discard your local changes, you can just do a
1383
1389
'bzr revert' instead of 'bzr commit' after the update.
1384
1385
If the tree's branch is bound to a master branch, it will also update
1386
the branch from the master.
1387
1390
"""
1388
1391
1389
1392
_see_also = ['pull', 'working-trees', 'status-flags']
1390
1393
takes_args = ['dir?']
1391
takes_options = ['revision']
1392
1394
aliases = ['up']
1393
1395
1394
def run(self, dir='.', revision=None):
1395
if revision is not None and len(revision) != 1:
1396
raise errors.BzrCommandError(
1397
"bzr update --revision takes exactly one revision")
1396
def run(self, dir='.'):
1398
1397
tree = WorkingTree.open_containing(dir)[0]
1399
branch = tree.branch
1400
1398
possible_transports = []
1401
master = branch.get_master_branch(
1399
master = tree.branch.get_master_branch(
1402
1400
possible_transports=possible_transports)
1403
1401
if master is not None:
1402
tree.lock_write()
1404
1403
branch_location = master.base
1405
tree.lock_write()
1406
1404
else:
1405
tree.lock_tree_write()
1407
1406
branch_location = tree.branch.base
1408
tree.lock_tree_write()
1409
self.add_cleanup(tree.unlock)
1410
1407
# get rid of the final '/' and be ready for display
1411
branch_location = urlutils.unescape_for_display(
1412
branch_location.rstrip('/'),
1413
self.outf.encoding)
1414
existing_pending_merges = tree.get_parent_ids()[1:]
1415
if master is None:
1416
old_tip = None
1417
else:
1418
# may need to fetch data into a heavyweight checkout
1419
# XXX: this may take some time, maybe we should display a
1420
# message
1421
old_tip = branch.update(possible_transports)
1422
if revision is not None:
1423
revision_id = revision[0].as_revision_id(branch)
1424
else:
1425
revision_id = branch.last_revision()
1426
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1427
revno = branch.revision_id_to_dotted_revno(revision_id)
1428
note("Tree is up to date at revision %s of branch %s" %
1429
('.'.join(map(str, revno)), branch_location))
1430
return 0
1431
view_info = _get_view_info_for_change_reporter(tree)
1432
change_reporter = delta._ChangeReporter(
1433
unversioned_filter=tree.is_ignored,
1434
view_info=view_info)
1408
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1409
self.outf.encoding)
1435
1410
try:
1411
existing_pending_merges = tree.get_parent_ids()[1:]
1412
last_rev = _mod_revision.ensure_null(tree.last_revision())
1413
if last_rev == _mod_revision.ensure_null(
1414
tree.branch.last_revision()):
1415
# may be up to date, check master too.
1416
if master is None or last_rev == _mod_revision.ensure_null(
1417
master.last_revision()):
1418
revno = tree.branch.revision_id_to_revno(last_rev)
1419
note('Tree is up to date at revision %d of branch %s'
1420
% (revno, branch_location))
1421
return 0
1422
view_info = _get_view_info_for_change_reporter(tree)
1436
1423
conflicts = tree.update(
1437
change_reporter,
1438
possible_transports=possible_transports,
1439
revision=revision_id,
1440
old_tip=old_tip)
1441
except errors.NoSuchRevision, e:
1442
raise errors.BzrCommandError(
1443
"branch has no revision %s\n"
1444
"bzr update --revision only works"
1445
" for a revision in the branch history"
1446
% (e.revision))
1447
revno = tree.branch.revision_id_to_dotted_revno(
1448
_mod_revision.ensure_null(tree.last_revision()))
1449
note('Updated to revision %s of branch %s' %
1450
('.'.join(map(str, revno)), branch_location))
1451
parent_ids = tree.get_parent_ids()
1452
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1453
note('Your local commits will now show as pending merges with '
1454
"'bzr status', and can be committed with 'bzr commit'.")
1455
if conflicts != 0:
1456
return 1
1457
else:
1458
return 0
1424
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1425
view_info=view_info), possible_transports=possible_transports)
1426
revno = tree.branch.revision_id_to_revno(
1427
_mod_revision.ensure_null(tree.last_revision()))
1428
note('Updated to revision %d of branch %s' %
1429
(revno, branch_location))
1430
if tree.get_parent_ids()[1:] != existing_pending_merges:
1431
note('Your local commits will now show as pending merges with '
1432
"'bzr status', and can be committed with 'bzr commit'.")
1433
if conflicts != 0:
1434
return 1
1435
else:
1436
return 0
1437
finally:
1438
tree.unlock()
1459
1439
1460
1440
1461
1441
class cmd_info(Command):
1462
__doc__ = """Show information about a working tree, branch or repository.
1442
"""Show information about a working tree, branch or repository.
1463
1443
1464
1444
This command will show all known locations and formats associated to the
1465
1445
tree, branch or repository.
1503
1483
1504
1484
1505
1485
class cmd_remove(Command):
1506
__doc__ = """Remove files or directories.
1486
"""Remove files or directories.
1507
1487
1508
1488
This makes bzr stop tracking changes to the specified files. bzr will delete
1509
1489
them if they can easily be recovered using revert. If no options or
1531
1511
if file_list is not None:
1532
1512
file_list = [f for f in file_list]
1533
1513
1534
self.add_cleanup(tree.lock_write().unlock)
1535
# Heuristics should probably all move into tree.remove_smart or
1536
# some such?
1537
if new:
1538
added = tree.changes_from(tree.basis_tree(),
1539
specific_files=file_list).added
1540
file_list = sorted([f[0] for f in added], reverse=True)
1541
if len(file_list) == 0:
1542
raise errors.BzrCommandError('No matching files.')
1543
elif file_list is None:
1544
# missing files show up in iter_changes(basis) as
1545
# versioned-with-no-kind.
1546
missing = []
1547
for change in tree.iter_changes(tree.basis_tree()):
1548
# Find paths in the working tree that have no kind:
1549
if change[1][1] is not None and change[6][1] is None:
1550
missing.append(change[1][1])
1551
file_list = sorted(missing, reverse=True)
1552
file_deletion_strategy = 'keep'
1553
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1554
keep_files=file_deletion_strategy=='keep',
1555
force=file_deletion_strategy=='force')
1514
tree.lock_write()
1515
try:
1516
# Heuristics should probably all move into tree.remove_smart or
1517
# some such?
1518
if new:
1519
added = tree.changes_from(tree.basis_tree(),
1520
specific_files=file_list).added
1521
file_list = sorted([f[0] for f in added], reverse=True)
1522
if len(file_list) == 0:
1523
raise errors.BzrCommandError('No matching files.')
1524
elif file_list is None:
1525
# missing files show up in iter_changes(basis) as
1526
# versioned-with-no-kind.
1527
missing = []
1528
for change in tree.iter_changes(tree.basis_tree()):
1529
# Find paths in the working tree that have no kind:
1530
if change[1][1] is not None and change[6][1] is None:
1531
missing.append(change[1][1])
1532
file_list = sorted(missing, reverse=True)
1533
file_deletion_strategy = 'keep'
1534
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1535
keep_files=file_deletion_strategy=='keep',
1536
force=file_deletion_strategy=='force')
1537
finally:
1538
tree.unlock()
1556
1539
1557
1540
1558
1541
class cmd_file_id(Command):
1559
__doc__ = """Print file_id of a particular file or directory.
1542
"""Print file_id of a particular file or directory.
1560
1543
1561
1544
The file_id is assigned when the file is first added and remains the
1562
1545
same through all revisions where the file exists, even when it is
1578
1561
1579
1562
1580
1563
class cmd_file_path(Command):
1581
__doc__ = """Print path of file_ids to a file or directory.
1564
"""Print path of file_ids to a file or directory.
1582
1565
1583
1566
This prints one line for each directory down to the target,
1584
1567
starting at the branch root.
1600
1583
1601
1584
1602
1585
class cmd_reconcile(Command):
1603
__doc__ = """Reconcile bzr metadata in a branch.
1586
"""Reconcile bzr metadata in a branch.
1604
1587
1605
1588
This can correct data mismatches that may have been caused by
1606
1589
previous ghost operations or bzr upgrades. You should only
1628
1611
1629
1612
1630
1613
class cmd_revision_history(Command):
1631
__doc__ = """Display the list of revision ids on a branch."""
1614
"""Display the list of revision ids on a branch."""
1632
1615
1633
1616
_see_also = ['log']
1634
1617
takes_args = ['location?']
1644
1627
1645
1628
1646
1629
class cmd_ancestry(Command):
1647
__doc__ = """List all revisions merged into this branch."""
1630
"""List all revisions merged into this branch."""
1648
1631
1649
1632
_see_also = ['log', 'revision-history']
1650
1633
takes_args = ['location?']
1669
1652
1670
1653
1671
1654
class cmd_init(Command):
1672
__doc__ = """Make a directory into a versioned branch.
1655
"""Make a directory into a versioned branch.
1673
1656
1674
1657
Use this to create an empty branch, or before importing an
1675
1658
existing project.
1778
1761
1779
1762
1780
1763
class cmd_init_repository(Command):
1781
__doc__ = """Create a shared repository for branches to share storage space.
1764
"""Create a shared repository for branches to share storage space.
1782
1765
1783
1766
New branches created under the repository directory will store their
1784
1767
revisions in the repository, not in the branch directory. For branches
1838
1821
1839
1822
1840
1823
class cmd_diff(Command):
1841
__doc__ = """Show differences in the working tree, between revisions or branches.
1824
"""Show differences in the working tree, between revisions or branches.
1842
1825
1843
1826
If no arguments are given, all changes for the current tree are listed.
1844
1827
If files are given, only the changes in those files are listed.
1930
1913
help='Use this command to compare files.',
1931
1914
type=unicode,
1932
1915
),
1933
RegistryOption('format',
1934
help='Diff format to use.',
1935
lazy_registry=('bzrlib.diff', 'format_registry'),
1936
value_switches=False, title='Diff format'),
1937
1916
]
1938
1917
aliases = ['di', 'dif']
1939
1918
encoding_type = 'exact'
1940
1919
1941
1920
@display_command
1942
1921
def run(self, revision=None, file_list=None, diff_options=None,
1943
prefix=None, old=None, new=None, using=None, format=None):
1944
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1945
show_diff_trees)
1922
prefix=None, old=None, new=None, using=None):
1923
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1946
1924
1947
1925
if (prefix is None) or (prefix == '0'):
1948
1926
# diff -p0 format
1962
1940
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1963
1941
' one or two revision specifiers')
1964
1942
1965
if using is not None and format is not None:
1966
raise errors.BzrCommandError('--using and --format are mutually '
1967
'exclusive.')
1968
1969
1943
(old_tree, new_tree,
1970
1944
old_branch, new_branch,
1971
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1972
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1973
# GNU diff on Windows uses ANSI encoding for filenames
1974
path_encoding = osutils.get_diff_header_encoding()
1945
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1946
file_list, revision, old, new, apply_view=True)
1975
1947
return show_diff_trees(old_tree, new_tree, sys.stdout,
1976
1948
specific_files=specific_files,
1977
1949
external_diff_options=diff_options,
1978
1950
old_label=old_label, new_label=new_label,
1979
extra_trees=extra_trees,
1980
path_encoding=path_encoding,
1981
using=using,
1982
format_cls=format)
1951
extra_trees=extra_trees, using=using)
1983
1952
1984
1953
1985
1954
class cmd_deleted(Command):
1986
__doc__ = """List files deleted in the working tree.
1955
"""List files deleted in the working tree.
1987
1956
"""
1988
1957
# TODO: Show files deleted since a previous revision, or
1989
1958
# between two revisions.
1992
1961
# level of effort but possibly much less IO. (Or possibly not,
1993
1962
# if the directories are very large...)
1994
1963
_see_also = ['status', 'ls']
1995
takes_options = ['directory', 'show-ids']
1964
takes_options = ['show-ids']
1996
1965
1997
1966
@display_command
1998
def run(self, show_ids=False, directory=u'.'):
1999
tree = WorkingTree.open_containing(directory)[0]
2000
self.add_cleanup(tree.lock_read().unlock)
2001
old = tree.basis_tree()
2002
self.add_cleanup(old.lock_read().unlock)
2003
for path, ie in old.inventory.iter_entries():
2004
if not tree.has_id(ie.file_id):
2005
self.outf.write(path)
2006
if show_ids:
2007
self.outf.write(' ')
2008
self.outf.write(ie.file_id)
2009
self.outf.write('\n')
1967
def run(self, show_ids=False):
1968
tree = WorkingTree.open_containing(u'.')[0]
1969
tree.lock_read()
1970
try:
1971
old = tree.basis_tree()
1972
old.lock_read()
1973
try:
1974
for path, ie in old.inventory.iter_entries():
1975
if not tree.has_id(ie.file_id):
1976
self.outf.write(path)
1977
if show_ids:
1978
self.outf.write(' ')
1979
self.outf.write(ie.file_id)
1980
self.outf.write('\n')
1981
finally:
1982
old.unlock()
1983
finally:
1984
tree.unlock()
2010
1985
2011
1986
2012
1987
class cmd_modified(Command):
2013
__doc__ = """List files modified in working tree.
1988
"""List files modified in working tree.
2014
1989
"""
2015
1990
2016
1991
hidden = True
2017
1992
_see_also = ['status', 'ls']
2018
takes_options = ['directory', 'null']
1993
takes_options = [
1994
Option('null',
1995
help='Write an ascii NUL (\\0) separator '
1996
'between files rather than a newline.')
1997
]
2019
1998
2020
1999
@display_command
2021
def run(self, null=False, directory=u'.'):
2022
tree = WorkingTree.open_containing(directory)[0]
2000
def run(self, null=False):
2001
tree = WorkingTree.open_containing(u'.')[0]
2023
2002
td = tree.changes_from(tree.basis_tree())
2024
2003
for path, id, kind, text_modified, meta_modified in td.modified:
2025
2004
if null:
2029
2008
2030
2009
2031
2010
class cmd_added(Command):
2032
__doc__ = """List files added in working tree.
2011
"""List files added in working tree.
2033
2012
"""
2034
2013
2035
2014
hidden = True
2036
2015
_see_also = ['status', 'ls']
2037
takes_options = ['directory', 'null']
2016
takes_options = [
2017
Option('null',
2018
help='Write an ascii NUL (\\0) separator '
2019
'between files rather than a newline.')
2020
]
2038
2021
2039
2022
@display_command
2040
def run(self, null=False, directory=u'.'):
2041
wt = WorkingTree.open_containing(directory)[0]
2042
self.add_cleanup(wt.lock_read().unlock)
2043
basis = wt.basis_tree()
2044
self.add_cleanup(basis.lock_read().unlock)
2045
basis_inv = basis.inventory
2046
inv = wt.inventory
2047
for file_id in inv:
2048
if file_id in basis_inv:
2049
continue
2050
if inv.is_root(file_id) and len(basis_inv) == 0:
2051
continue
2052
path = inv.id2path(file_id)
2053
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2054
continue
2055
if null:
2056
self.outf.write(path + '\0')
2057
else:
2058
self.outf.write(osutils.quotefn(path) + '\n')
2023
def run(self, null=False):
2024
wt = WorkingTree.open_containing(u'.')[0]
2025
wt.lock_read()
2026
try:
2027
basis = wt.basis_tree()
2028
basis.lock_read()
2029
try:
2030
basis_inv = basis.inventory
2031
inv = wt.inventory
2032
for file_id in inv:
2033
if file_id in basis_inv:
2034
continue
2035
if inv.is_root(file_id) and len(basis_inv) == 0:
2036
continue
2037
path = inv.id2path(file_id)
2038
if not os.access(osutils.abspath(path), os.F_OK):
2039
continue
2040
if null:
2041
self.outf.write(path + '\0')
2042
else:
2043
self.outf.write(osutils.quotefn(path) + '\n')
2044
finally:
2045
basis.unlock()
2046
finally:
2047
wt.unlock()
2059
2048
2060
2049
2061
2050
class cmd_root(Command):
2062
__doc__ = """Show the tree root directory.
2051
"""Show the tree root directory.
2063
2052
2064
2053
The root is the nearest enclosing directory with a .bzr control
2065
2054
directory."""
2089
2078
2090
2079
2091
2080
class cmd_log(Command):
2092
__doc__ = """Show historical log for a branch or subset of a branch.
2081
"""Show historical log for a branch or subset of a branch.
2093
2082
2094
2083
log is bzr's default tool for exploring the history of a branch.
2095
2084
The branch to use is taken from the first parameter. If no parameters
2206
2195
:Tips & tricks:
2207
2196
2208
2197
GUI tools and IDEs are often better at exploring history than command
2209
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2210
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2211
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2212
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2198
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2199
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2200
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2201
2202
Web interfaces are often better at exploring history than command line
2203
tools, particularly for branches on servers. You may prefer Loggerhead
2204
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2213
2205
2214
2206
You may find it useful to add the aliases below to ``bazaar.conf``::
2215
2207
2256
2248
help='Show just the specified revision.'
2257
2249
' See also "help revisionspec".'),
2258
2250
'log-format',
2259
RegistryOption('authors',
2260
'What names to list as authors - first, all or committer.',
2261
title='Authors',
2262
lazy_registry=('bzrlib.log', 'author_list_registry'),
2263
),
2264
2251
Option('levels',
2265
2252
short_name='n',
2266
2253
help='Number of levels to display - 0 for all, 1 for flat.',
2281
2268
help='Show changes made in each revision as a patch.'),
2282
2269
Option('include-merges',
2283
2270
help='Show merged revisions like --levels 0 does.'),
2284
Option('exclude-common-ancestry',
2285
help='Display only the revisions that are not part'
2286
' of both ancestries (require -rX..Y)'
2287
)
2288
2271
]
2289
2272
encoding_type = 'replace'
2290
2273
2300
2283
message=None,
2301
2284
limit=None,
2302
2285
show_diff=False,
2303
include_merges=False,
2304
authors=None,
2305
exclude_common_ancestry=False,
2306
):
2286
include_merges=False):
2307
2287
from bzrlib.log import (
2308
2288
Logger,
2309
2289
make_log_request_dict,
2310
2290
_get_info_for_log_files,
2311
2291
)
2312
2292
direction = (forward and 'forward') or 'reverse'
2313
if (exclude_common_ancestry
2314
and (revision is None or len(revision) != 2)):
2315
raise errors.BzrCommandError(
2316
'--exclude-common-ancestry requires -r with two revisions')
2317
2293
if include_merges:
2318
2294
if levels is None:
2319
2295
levels = 0
2332
2308
2333
2309
file_ids = []
2334
2310
filter_by_dir = False
2335
if file_list:
2336
# find the file ids to log and check for directory filtering
2337
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2338
revision, file_list, self.add_cleanup)
2339
for relpath, file_id, kind in file_info_list:
2340
if file_id is None:
2341
raise errors.BzrCommandError(
2342
"Path unknown at end or start of revision range: %s" %
2343
relpath)
2344
# If the relpath is the top of the tree, we log everything
2345
if relpath == '':
2346
file_ids = []
2347
break
2311
b = None
2312
try:
2313
if file_list:
2314
# find the file ids to log and check for directory filtering
2315
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2316
revision, file_list)
2317
for relpath, file_id, kind in file_info_list:
2318
if file_id is None:
2319
raise errors.BzrCommandError(
2320
"Path unknown at end or start of revision range: %s" %
2321
relpath)
2322
# If the relpath is the top of the tree, we log everything
2323
if relpath == '':
2324
file_ids = []
2325
break
2326
else:
2327
file_ids.append(file_id)
2328
filter_by_dir = filter_by_dir or (
2329
kind in ['directory', 'tree-reference'])
2330
else:
2331
# log everything
2332
# FIXME ? log the current subdir only RBC 20060203
2333
if revision is not None \
2334
and len(revision) > 0 and revision[0].get_branch():
2335
location = revision[0].get_branch()
2348
2336
else:
2349
file_ids.append(file_id)
2350
filter_by_dir = filter_by_dir or (
2351
kind in ['directory', 'tree-reference'])
2352
else:
2353
# log everything
2354
# FIXME ? log the current subdir only RBC 20060203
2355
if revision is not None \
2356
and len(revision) > 0 and revision[0].get_branch():
2357
location = revision[0].get_branch()
2358
else:
2359
location = '.'
2360
dir, relpath = bzrdir.BzrDir.open_containing(location)
2361
b = dir.open_branch()
2362
self.add_cleanup(b.lock_read().unlock)
2363
rev1, rev2 = _get_revision_range(revision, b, self.name())
2364
2365
# Decide on the type of delta & diff filtering to use
2366
# TODO: add an --all-files option to make this configurable & consistent
2367
if not verbose:
2368
delta_type = None
2369
else:
2370
delta_type = 'full'
2371
if not show_diff:
2372
diff_type = None
2373
elif file_ids:
2374
diff_type = 'partial'
2375
else:
2376
diff_type = 'full'
2377
2378
# Build the log formatter
2379
if log_format is None:
2380
log_format = log.log_formatter_registry.get_default(b)
2381
# Make a non-encoding output to include the diffs - bug 328007
2382
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2383
lf = log_format(show_ids=show_ids, to_file=self.outf,
2384
to_exact_file=unencoded_output,
2385
show_timezone=timezone,
2386
delta_format=get_verbosity_level(),
2387
levels=levels,
2388
show_advice=levels is None,
2389
author_list_handler=authors)
2390
2391
# Choose the algorithm for doing the logging. It's annoying
2392
# having multiple code paths like this but necessary until
2393
# the underlying repository format is faster at generating
2394
# deltas or can provide everything we need from the indices.
2395
# The default algorithm - match-using-deltas - works for
2396
# multiple files and directories and is faster for small
2397
# amounts of history (200 revisions say). However, it's too
2398
# slow for logging a single file in a repository with deep
2399
# history, i.e. > 10K revisions. In the spirit of "do no
2400
# evil when adding features", we continue to use the
2401
# original algorithm - per-file-graph - for the "single
2402
# file that isn't a directory without showing a delta" case.
2403
partial_history = revision and b.repository._format.supports_chks
2404
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2405
or delta_type or partial_history)
2406
2407
# Build the LogRequest and execute it
2408
if len(file_ids) == 0:
2409
file_ids = None
2410
rqst = make_log_request_dict(
2411
direction=direction, specific_fileids=file_ids,
2412
start_revision=rev1, end_revision=rev2, limit=limit,
2413
message_search=message, delta_type=delta_type,
2414
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2415
exclude_common_ancestry=exclude_common_ancestry,
2416
)
2417
Logger(b, rqst).show(lf)
2337
location = '.'
2338
dir, relpath = bzrdir.BzrDir.open_containing(location)
2339
b = dir.open_branch()
2340
b.lock_read()
2341
rev1, rev2 = _get_revision_range(revision, b, self.name())
2342
2343
# Decide on the type of delta & diff filtering to use
2344
# TODO: add an --all-files option to make this configurable & consistent
2345
if not verbose:
2346
delta_type = None
2347
else:
2348
delta_type = 'full'
2349
if not show_diff:
2350
diff_type = None
2351
elif file_ids:
2352
diff_type = 'partial'
2353
else:
2354
diff_type = 'full'
2355
2356
# Build the log formatter
2357
if log_format is None:
2358
log_format = log.log_formatter_registry.get_default(b)
2359
# Make a non-encoding output to include the diffs - bug 328007
2360
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2361
lf = log_format(show_ids=show_ids, to_file=self.outf,
2362
to_exact_file=unencoded_output,
2363
show_timezone=timezone,
2364
delta_format=get_verbosity_level(),
2365
levels=levels,
2366
show_advice=levels is None)
2367
2368
# Choose the algorithm for doing the logging. It's annoying
2369
# having multiple code paths like this but necessary until
2370
# the underlying repository format is faster at generating
2371
# deltas or can provide everything we need from the indices.
2372
# The default algorithm - match-using-deltas - works for
2373
# multiple files and directories and is faster for small
2374
# amounts of history (200 revisions say). However, it's too
2375
# slow for logging a single file in a repository with deep
2376
# history, i.e. > 10K revisions. In the spirit of "do no
2377
# evil when adding features", we continue to use the
2378
# original algorithm - per-file-graph - for the "single
2379
# file that isn't a directory without showing a delta" case.
2380
partial_history = revision and b.repository._format.supports_chks
2381
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2382
or delta_type or partial_history)
2383
2384
# Build the LogRequest and execute it
2385
if len(file_ids) == 0:
2386
file_ids = None
2387
rqst = make_log_request_dict(
2388
direction=direction, specific_fileids=file_ids,
2389
start_revision=rev1, end_revision=rev2, limit=limit,
2390
message_search=message, delta_type=delta_type,
2391
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2392
Logger(b, rqst).show(lf)
2393
finally:
2394
if b is not None:
2395
b.unlock()
2418
2396
2419
2397
2420
2398
def _get_revision_range(revisionspec_list, branch, command_name):
2438
2416
raise errors.BzrCommandError(
2439
2417
"bzr %s doesn't accept two revisions in different"
2440
2418
" branches." % command_name)
2441
if start_spec.spec is None:
2442
# Avoid loading all the history.
2443
rev1 = RevisionInfo(branch, None, None)
2444
else:
2445
rev1 = start_spec.in_history(branch)
2419
rev1 = start_spec.in_history(branch)
2446
2420
# Avoid loading all of history when we know a missing
2447
2421
# end of range means the last revision ...
2448
2422
if end_spec.spec is None:
2477
2451
2478
2452
2479
2453
class cmd_touching_revisions(Command):
2480
__doc__ = """Return revision-ids which affected a particular file.
2454
"""Return revision-ids which affected a particular file.
2481
2455
2482
2456
A more user-friendly interface is "bzr log FILE".
2483
2457
"""
2490
2464
tree, relpath = WorkingTree.open_containing(filename)
2491
2465
file_id = tree.path2id(relpath)
2492
2466
b = tree.branch
2493
self.add_cleanup(b.lock_read().unlock)
2494
touching_revs = log.find_touching_revisions(b, file_id)
2495
for revno, revision_id, what in touching_revs:
2496
self.outf.write("%6d %s\n" % (revno, what))
2467
b.lock_read()
2468
try:
2469
touching_revs = log.find_touching_revisions(b, file_id)
2470
for revno, revision_id, what in touching_revs:
2471
self.outf.write("%6d %s\n" % (revno, what))
2472
finally:
2473
b.unlock()
2497
2474
2498
2475
2499
2476
class cmd_ls(Command):
2500
__doc__ = """List files in a tree.
2477
"""List files in a tree.
2501
2478
"""
2502
2479
2503
2480
_see_also = ['status', 'cat']
2509
2486
help='Recurse into subdirectories.'),
2510
2487
Option('from-root',
2511
2488
help='Print paths relative to the root of the branch.'),
2512
Option('unknown', short_name='u',
2513
help='Print unknown files.'),
2489
Option('unknown', help='Print unknown files.'),
2514
2490
Option('versioned', help='Print versioned files.',
2515
2491
short_name='V'),
2516
Option('ignored', short_name='i',
2517
help='Print ignored files.'),
2518
Option('kind', short_name='k',
2492
Option('ignored', help='Print ignored files.'),
2493
Option('null',
2494
help='Write an ascii NUL (\\0) separator '
2495
'between files rather than a newline.'),
2496
Option('kind',
2519
2497
help='List entries of a particular kind: file, directory, symlink.',
2520
2498
type=unicode),
2521
'null',
2522
2499
'show-ids',
2523
'directory',
2524
2500
]
2525
2501
@display_command
2526
2502
def run(self, revision=None, verbose=False,
2527
2503
recursive=False, from_root=False,
2528
2504
unknown=False, versioned=False, ignored=False,
2529
null=False, kind=None, show_ids=False, path=None, directory=None):
2505
null=False, kind=None, show_ids=False, path=None):
2530
2506
2531
2507
if kind and kind not in ('file', 'directory', 'symlink'):
2532
2508
raise errors.BzrCommandError('invalid kind specified')
2544
2520
raise errors.BzrCommandError('cannot specify both --from-root'
2545
2521
' and PATH')
2546
2522
fs_path = path
2547
tree, branch, relpath = \
2548
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2523
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2524
fs_path)
2549
2525
2550
2526
# Calculate the prefix to use
2551
2527
prefix = None
2566
2542
view_str = views.view_display_str(view_files)
2567
2543
note("Ignoring files outside view. View is %s" % view_str)
2568
2544
2569
self.add_cleanup(tree.lock_read().unlock)
2570
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2571
from_dir=relpath, recursive=recursive):
2572
# Apply additional masking
2573
if not all and not selection[fc]:
2574
continue
2575
if kind is not None and fkind != kind:
2576
continue
2577
if apply_view:
2578
try:
2579
if relpath:
2580
fullpath = osutils.pathjoin(relpath, fp)
2581
else:
2582
fullpath = fp
2583
views.check_path_in_view(tree, fullpath)
2584
except errors.FileOutsideView:
2585
continue
2545
tree.lock_read()
2546
try:
2547
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2548
from_dir=relpath, recursive=recursive):
2549
# Apply additional masking
2550
if not all and not selection[fc]:
2551
continue
2552
if kind is not None and fkind != kind:
2553
continue
2554
if apply_view:
2555
try:
2556
if relpath:
2557
fullpath = osutils.pathjoin(relpath, fp)
2558
else:
2559
fullpath = fp
2560
views.check_path_in_view(tree, fullpath)
2561
except errors.FileOutsideView:
2562
continue
2586
2563
2587
# Output the entry
2588
if prefix:
2589
fp = osutils.pathjoin(prefix, fp)
2590
kindch = entry.kind_character()
2591
outstring = fp + kindch
2592
ui.ui_factory.clear_term()
2593
if verbose:
2594
outstring = '%-8s %s' % (fc, outstring)
2595
if show_ids and fid is not None:
2596
outstring = "%-50s %s" % (outstring, fid)
2597
self.outf.write(outstring + '\n')
2598
elif null:
2599
self.outf.write(fp + '\0')
2600
if show_ids:
2601
if fid is not None:
2602
self.outf.write(fid)
2603
self.outf.write('\0')
2604
self.outf.flush()
2605
else:
2606
if show_ids:
2607
if fid is not None:
2608
my_id = fid
2609
else:
2610
my_id = ''
2611
self.outf.write('%-50s %s\n' % (outstring, my_id))
2612
else:
2564
# Output the entry
2565
if prefix:
2566
fp = osutils.pathjoin(prefix, fp)
2567
kindch = entry.kind_character()
2568
outstring = fp + kindch
2569
ui.ui_factory.clear_term()
2570
if verbose:
2571
outstring = '%-8s %s' % (fc, outstring)
2572
if show_ids and fid is not None:
2573
outstring = "%-50s %s" % (outstring, fid)
2613
2574
self.outf.write(outstring + '\n')
2575
elif null:
2576
self.outf.write(fp + '\0')
2577
if show_ids:
2578
if fid is not None:
2579
self.outf.write(fid)
2580
self.outf.write('\0')
2581
self.outf.flush()
2582
else:
2583
if show_ids:
2584
if fid is not None:
2585
my_id = fid
2586
else:
2587
my_id = ''
2588
self.outf.write('%-50s %s\n' % (outstring, my_id))
2589
else:
2590
self.outf.write(outstring + '\n')
2591
finally:
2592
tree.unlock()
2614
2593
2615
2594
2616
2595
class cmd_unknowns(Command):
2617
__doc__ = """List unknown files.
2596
"""List unknown files.
2618
2597
"""
2619
2598
2620
2599
hidden = True
2621
2600
_see_also = ['ls']
2622
takes_options = ['directory']
2623
2601
2624
2602
@display_command
2625
def run(self, directory=u'.'):
2626
for f in WorkingTree.open_containing(directory)[0].unknowns():
2603
def run(self):
2604
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2627
2605
self.outf.write(osutils.quotefn(f) + '\n')
2628
2606
2629
2607
2630
2608
class cmd_ignore(Command):
2631
__doc__ = """Ignore specified files or patterns.
2609
"""Ignore specified files or patterns.
2632
2610
2633
2611
See ``bzr help patterns`` for details on the syntax of patterns.
2634
2612
2642
2620
After adding, editing or deleting that file either indirectly by
2643
2621
using this command or directly by using an editor, be sure to commit
2644
2622
it.
2645
2646
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2647
the global ignore file can be found in the application data directory as
2648
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2649
Global ignores are not touched by this command. The global ignore file
2650
can be edited directly using an editor.
2651
2652
Patterns prefixed with '!' are exceptions to ignore patterns and take
2653
precedence over regular ignores. Such exceptions are used to specify
2654
files that should be versioned which would otherwise be ignored.
2655
2656
Patterns prefixed with '!!' act as regular ignore patterns, but have
2657
precedence over the '!' exception patterns.
2658
2623
2659
2624
Note: ignore patterns containing shell wildcards must be quoted from
2660
2625
the shell on Unix.
2664
2629
2665
2630
bzr ignore ./Makefile
2666
2631
2667
Ignore .class files in all directories...::
2632
Ignore class files in all directories::
2668
2633
2669
2634
bzr ignore "*.class"
2670
2635
2671
...but do not ignore "special.class"::
2672
2673
bzr ignore "!special.class"
2674
2675
2636
Ignore .o files under the lib directory::
2676
2637
2677
2638
bzr ignore "lib/**/*.o"
2683
2644
Ignore everything but the "debian" toplevel directory::
2684
2645
2685
2646
bzr ignore "RE:(?!debian/).*"
2686
2687
Ignore everything except the "local" toplevel directory,
2688
but always ignore "*~" autosave files, even under local/::
2689
2690
bzr ignore "*"
2691
bzr ignore "!./local"
2692
bzr ignore "!!*~"
2693
2647
"""
2694
2648
2695
2649
_see_also = ['status', 'ignored', 'patterns']
2696
2650
takes_args = ['name_pattern*']
2697
takes_options = ['directory',
2698
Option('default-rules',
2699
help='Display the default ignore rules that bzr uses.')
2651
takes_options = [
2652
Option('old-default-rules',
2653
help='Write out the ignore rules bzr < 0.9 always used.')
2700
2654
]
2701
2655
2702
def run(self, name_pattern_list=None, default_rules=None,
2703
directory=u'.'):
2656
def run(self, name_pattern_list=None, old_default_rules=None):
2704
2657
from bzrlib import ignores
2705
if default_rules is not None:
2706
# dump the default rules and exit
2707
for pattern in ignores.USER_DEFAULTS:
2708
self.outf.write("%s\n" % pattern)
2658
if old_default_rules is not None:
2659
# dump the rules and exit
2660
for pattern in ignores.OLD_DEFAULTS:
2661
print pattern
2709
2662
return
2710
2663
if not name_pattern_list:
2711
2664
raise errors.BzrCommandError("ignore requires at least one "
2712
"NAME_PATTERN or --default-rules.")
2665
"NAME_PATTERN or --old-default-rules")
2713
2666
name_pattern_list = [globbing.normalize_pattern(p)
2714
2667
for p in name_pattern_list]
2715
bad_patterns = ''
2716
for p in name_pattern_list:
2717
if not globbing.Globster.is_pattern_valid(p):
2718
bad_patterns += ('\n %s' % p)
2719
if bad_patterns:
2720
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2721
ui.ui_factory.show_error(msg)
2722
raise errors.InvalidPattern('')
2723
2668
for name_pattern in name_pattern_list:
2724
2669
if (name_pattern[0] == '/' or
2725
2670
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2726
2671
raise errors.BzrCommandError(
2727
2672
"NAME_PATTERN should not be an absolute path")
2728
tree, relpath = WorkingTree.open_containing(directory)
2673
tree, relpath = WorkingTree.open_containing(u'.')
2729
2674
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2730
2675
ignored = globbing.Globster(name_pattern_list)
2731
2676
matches = []
2732
self.add_cleanup(tree.lock_read().unlock)
2677
tree.lock_read()
2733
2678
for entry in tree.list_files():
2734
2679
id = entry[3]
2735
2680
if id is not None:
2736
2681
filename = entry[0]
2737
2682
if ignored.match(filename):
2738
matches.append(filename)
2683
matches.append(filename.encode('utf-8'))
2684
tree.unlock()
2739
2685
if len(matches) > 0:
2740
self.outf.write("Warning: the following files are version controlled and"
2741
" match your ignore pattern:\n%s"
2742
"\nThese files will continue to be version controlled"
2743
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2686
print "Warning: the following files are version controlled and" \
2687
" match your ignore pattern:\n%s" \
2688
"\nThese files will continue to be version controlled" \
2689
" unless you 'bzr remove' them." % ("\n".join(matches),)
2744
2690
2745
2691
2746
2692
class cmd_ignored(Command):
2747
__doc__ = """List ignored files and the patterns that matched them.
2693
"""List ignored files and the patterns that matched them.
2748
2694
2749
2695
List all the ignored files and the ignore pattern that caused the file to
2750
2696
be ignored.
2756
2702
2757
2703
encoding_type = 'replace'
2758
2704
_see_also = ['ignore', 'ls']
2759
takes_options = ['directory']
2760
2705
2761
2706
@display_command
2762
def run(self, directory=u'.'):
2763
tree = WorkingTree.open_containing(directory)[0]
2764
self.add_cleanup(tree.lock_read().unlock)
2765
for path, file_class, kind, file_id, entry in tree.list_files():
2766
if file_class != 'I':
2767
continue
2768
## XXX: Slightly inefficient since this was already calculated
2769
pat = tree.is_ignored(path)
2770
self.outf.write('%-50s %s\n' % (path, pat))
2707
def run(self):
2708
tree = WorkingTree.open_containing(u'.')[0]
2709
tree.lock_read()
2710
try:
2711
for path, file_class, kind, file_id, entry in tree.list_files():
2712
if file_class != 'I':
2713
continue
2714
## XXX: Slightly inefficient since this was already calculated
2715
pat = tree.is_ignored(path)
2716
self.outf.write('%-50s %s\n' % (path, pat))
2717
finally:
2718
tree.unlock()
2771
2719
2772
2720
2773
2721
class cmd_lookup_revision(Command):
2774
__doc__ = """Lookup the revision-id from a revision-number
2722
"""Lookup the revision-id from a revision-number
2775
2723
2776
2724
:Examples:
2777
2725
bzr lookup-revision 33
2778
2726
"""
2779
2727
hidden = True
2780
2728
takes_args = ['revno']
2781
takes_options = ['directory']
2782
2729
2783
2730
@display_command
2784
def run(self, revno, directory=u'.'):
2731
def run(self, revno):
2785
2732
try:
2786
2733
revno = int(revno)
2787
2734
except ValueError:
2788
raise errors.BzrCommandError("not a valid revision-number: %r"
2789
% revno)
2790
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2791
self.outf.write("%s\n" % revid)
2735
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2736
2737
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2792
2738
2793
2739
2794
2740
class cmd_export(Command):
2795
__doc__ = """Export current or past revision to a destination directory or archive.
2741
"""Export current or past revision to a destination directory or archive.
2796
2742
2797
2743
If no revision is specified this exports the last committed revision.
2798
2744
2820
2766
================= =========================
2821
2767
"""
2822
2768
takes_args = ['dest', 'branch_or_subdir?']
2823
takes_options = ['directory',
2769
takes_options = [
2824
2770
Option('format',
2825
2771
help="Type of file to export to.",
2826
2772
type=unicode),
2830
2776
Option('root',
2831
2777
type=str,
2832
2778
help="Name of the root directory inside the exported file."),
2833
Option('per-file-timestamps',
2834
help='Set modification time of files to that of the last '
2835
'revision in which it was changed.'),
2836
2779
]
2837
2780
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2838
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2781
root=None, filters=False):
2839
2782
from bzrlib.export import export
2840
2783
2841
2784
if branch_or_subdir is None:
2842
tree = WorkingTree.open_containing(directory)[0]
2785
tree = WorkingTree.open_containing(u'.')[0]
2843
2786
b = tree.branch
2844
2787
subdir = None
2845
2788
else:
2848
2791
2849
2792
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2850
2793
try:
2851
export(rev_tree, dest, format, root, subdir, filtered=filters,
2852
per_file_timestamps=per_file_timestamps)
2794
export(rev_tree, dest, format, root, subdir, filtered=filters)
2853
2795
except errors.NoSuchExportFormat, e:
2854
2796
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2855
2797
2856
2798
2857
2799
class cmd_cat(Command):
2858
__doc__ = """Write the contents of a file as of a given revision to standard output.
2800
"""Write the contents of a file as of a given revision to standard output.
2859
2801
2860
2802
If no revision is nominated, the last revision is used.
2861
2803
2864
2806
"""
2865
2807
2866
2808
_see_also = ['ls']
2867
takes_options = ['directory',
2809
takes_options = [
2868
2810
Option('name-from-revision', help='The path name in the old tree.'),
2869
2811
Option('filters', help='Apply content filters to display the '
2870
2812
'convenience form.'),
2875
2817
2876
2818
@display_command
2877
2819
def run(self, filename, revision=None, name_from_revision=False,
2878
filters=False, directory=None):
2820
filters=False):
2879
2821
if revision is not None and len(revision) != 1:
2880
2822
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2881
2823
" one revision specifier")
2882
2824
tree, branch, relpath = \
2883
_open_directory_or_containing_tree_or_branch(filename, directory)
2884
self.add_cleanup(branch.lock_read().unlock)
2885
return self._run(tree, branch, relpath, filename, revision,
2886
name_from_revision, filters)
2825
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2826
branch.lock_read()
2827
try:
2828
return self._run(tree, branch, relpath, filename, revision,
2829
name_from_revision, filters)
2830
finally:
2831
branch.unlock()
2887
2832
2888
2833
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2889
2834
filtered):
2890
2835
if tree is None:
2891
2836
tree = b.basis_tree()
2892
2837
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2893
self.add_cleanup(rev_tree.lock_read().unlock)
2894
2838
2895
2839
old_file_id = rev_tree.path2id(relpath)
2896
2840
2931
2875
chunks = content.splitlines(True)
2932
2876
content = filtered_output_bytes(chunks, filters,
2933
2877
ContentFilterContext(relpath, rev_tree))
2934
self.cleanup_now()
2935
2878
self.outf.writelines(content)
2936
2879
else:
2937
self.cleanup_now()
2938
2880
self.outf.write(content)
2939
2881
2940
2882
2941
2883
class cmd_local_time_offset(Command):
2942
__doc__ = """Show the offset in seconds from GMT to local time."""
2884
"""Show the offset in seconds from GMT to local time."""
2943
2885
hidden = True
2944
2886
@display_command
2945
2887
def run(self):
2946
self.outf.write("%s\n" % osutils.local_time_offset())
2888
print osutils.local_time_offset()
2947
2889
2948
2890
2949
2891
2950
2892
class cmd_commit(Command):
2951
__doc__ = """Commit changes into a new revision.
2893
"""Commit changes into a new revision.
2952
2894
2953
2895
An explanatory message needs to be given for each commit. This is
2954
2896
often done by using the --message option (getting the message from the
3062
3004
"the master branch until a normal commit "
3063
3005
"is performed."
3064
3006
),
3065
Option('show-diff', short_name='p',
3007
Option('show-diff',
3066
3008
help='When no message is supplied, show the diff along'
3067
3009
' with the status summary in the message editor.'),
3068
3010
]
3148
3090
'(use --file "%(f)s" to take commit message from that file)'
3149
3091
% { 'f': message })
3150
3092
ui.ui_factory.show_warning(warning_msg)
3151
if '\r' in message:
3152
message = message.replace('\r\n', '\n')
3153
message = message.replace('\r', '\n')
3154
if file:
3155
raise errors.BzrCommandError(
3156
"please specify either --message or --file")
3157
3093
3158
3094
def get_message(commit_obj):
3159
3095
"""Callback to get commit message"""
3160
if file:
3161
f = codecs.open(file, 'rt', osutils.get_user_encoding())
3162
try:
3163
my_message = f.read()
3164
finally:
3165
f.close()
3166
elif message is not None:
3167
my_message = message
3168
else:
3169
# No message supplied: make one up.
3170
# text is the status of the tree
3171
text = make_commit_message_template_encoded(tree,
3096
my_message = message
3097
if my_message is not None and '\r' in my_message:
3098
my_message = my_message.replace('\r\n', '\n')
3099
my_message = my_message.replace('\r', '\n')
3100
if my_message is None and not file:
3101
t = make_commit_message_template_encoded(tree,
3172
3102
selected_list, diff=show_diff,
3173
3103
output_encoding=osutils.get_user_encoding())
3174
# start_message is the template generated from hooks
3175
# XXX: Warning - looks like hooks return unicode,
3176
# make_commit_message_template_encoded returns user encoding.
3177
# We probably want to be using edit_commit_message instead to
3178
# avoid this.
3179
3104
start_message = generate_commit_message_template(commit_obj)
3180
my_message = edit_commit_message_encoded(text,
3105
my_message = edit_commit_message_encoded(t,
3181
3106
start_message=start_message)
3182
3107
if my_message is None:
3183
3108
raise errors.BzrCommandError("please specify a commit"
3184
3109
" message with either --message or --file")
3110
elif my_message and file:
3111
raise errors.BzrCommandError(
3112
"please specify either --message or --file")
3113
if file:
3114
my_message = codecs.open(file, 'rt',
3115
osutils.get_user_encoding()).read()
3185
3116
if my_message == "":
3186
3117
raise errors.BzrCommandError("empty commit message specified")
3187
3118
return my_message
3199
3130
timezone=offset,
3200
3131
exclude=safe_relpath_files(tree, exclude))
3201
3132
except PointlessCommit:
3133
# FIXME: This should really happen before the file is read in;
3134
# perhaps prepare the commit; get the message; then actually commit
3202
3135
raise errors.BzrCommandError("No changes to commit."
3203
3136
" Use --unchanged to commit anyhow.")
3204
3137
except ConflictsInTree:
3209
3142
raise errors.BzrCommandError("Commit refused because there are"
3210
3143
" unknown files in the working tree.")
3211
3144
except errors.BoundBranchOutOfDate, e:
3212
e.extra_help = ("\n"
3213
'To commit to master branch, run update and then commit.\n'
3214
'You can also pass --local to commit to continue working '
3215
'disconnected.')
3216
raise
3145
raise errors.BzrCommandError(str(e) + "\n"
3146
'To commit to master branch, run update and then commit.\n'
3147
'You can also pass --local to commit to continue working '
3148
'disconnected.')
3217
3149
3218
3150
3219
3151
class cmd_check(Command):
3220
__doc__ = """Validate working tree structure, branch consistency and repository history.
3152
"""Validate working tree structure, branch consistency and repository history.
3221
3153
3222
3154
This command checks various invariants about branch and repository storage
3223
3155
to detect data corruption or bzr bugs.
3287
3219
3288
3220
3289
3221
class cmd_upgrade(Command):
3290
__doc__ = """Upgrade branch storage to current format.
3222
"""Upgrade branch storage to current format.
3291
3223
3292
3224
The check command or bzr developers may sometimes advise you to run
3293
3225
this command. When the default format has changed you may also be warned
3311
3243
3312
3244
3313
3245
class cmd_whoami(Command):
3314
__doc__ = """Show or set bzr user id.
3246
"""Show or set bzr user id.
3315
3247
3316
3248
:Examples:
3317
3249
Show the email of the current user::
3322
3254
3323
3255
bzr whoami "Frank Chu <fchu@example.com>"
3324
3256
"""
3325
takes_options = [ 'directory',
3326
Option('email',
3257
takes_options = [ Option('email',
3327
3258
help='Display email address only.'),
3328
3259
Option('branch',
3329
3260
help='Set identity for the current branch instead of '
3333
3264
encoding_type = 'replace'
3334
3265
3335
3266
@display_command
3336
def run(self, email=False, branch=False, name=None, directory=None):
3267
def run(self, email=False, branch=False, name=None):
3337
3268
if name is None:
3338
if directory is None:
3339
# use branch if we're inside one; otherwise global config
3340
try:
3341
c = Branch.open_containing(u'.')[0].get_config()
3342
except errors.NotBranchError:
3343
c = config.GlobalConfig()
3344
else:
3345
c = Branch.open(directory).get_config()
3269
# use branch if we're inside one; otherwise global config
3270
try:
3271
c = Branch.open_containing('.')[0].get_config()
3272
except errors.NotBranchError:
3273
c = config.GlobalConfig()
3346
3274
if email:
3347
3275
self.outf.write(c.user_email() + '\n')
3348
3276
else:
3358
3286
3359
3287
# use global config unless --branch given
3360
3288
if branch:
3361
if directory is None:
3362
c = Branch.open_containing(u'.')[0].get_config()
3363
else:
3364
c = Branch.open(directory).get_config()
3289
c = Branch.open_containing('.')[0].get_config()
3365
3290
else:
3366
3291
c = config.GlobalConfig()
3367
3292
c.set_user_option('email', name)
3368
3293
3369
3294
3370
3295
class cmd_nick(Command):
3371
__doc__ = """Print or set the branch nickname.
3296
"""Print or set the branch nickname.
3372
3297
3373
3298
If unset, the tree root directory name is used as the nickname.
3374
3299
To print the current nickname, execute with no argument.
3379
3304
3380
3305
_see_also = ['info']
3381
3306
takes_args = ['nickname?']
3382
takes_options = ['directory']
3383
def run(self, nickname=None, directory=u'.'):
3384
branch = Branch.open_containing(directory)[0]
3307
def run(self, nickname=None):
3308
branch = Branch.open_containing(u'.')[0]
3385
3309
if nickname is None:
3386
3310
self.printme(branch)
3387
3311
else:
3389
3313
3390
3314
@display_command
3391
3315
def printme(self, branch):
3392
self.outf.write('%s\n' % branch.nick)
3316
print branch.nick
3393
3317
3394
3318
3395
3319
class cmd_alias(Command):
3396
__doc__ = """Set/unset and display aliases.
3320
"""Set/unset and display aliases.
3397
3321
3398
3322
:Examples:
3399
3323
Show the current aliases::
3463
3387
3464
3388
3465
3389
class cmd_selftest(Command):
3466
__doc__ = """Run internal test suite.
3390
"""Run internal test suite.
3467
3391
3468
3392
If arguments are given, they are regular expressions that say which tests
3469
3393
should run. Tests matching any expression are run, and other tests are
3513
3437
def get_transport_type(typestring):
3514
3438
"""Parse and return a transport specifier."""
3515
3439
if typestring == "sftp":
3516
from bzrlib.tests import stub_sftp
3517
return stub_sftp.SFTPAbsoluteServer
3440
from bzrlib.transport.sftp import SFTPAbsoluteServer
3441
return SFTPAbsoluteServer
3518
3442
if typestring == "memory":
3519
from bzrlib.tests import test_server
3520
return memory.MemoryServer
3443
from bzrlib.transport.memory import MemoryServer
3444
return MemoryServer
3521
3445
if typestring == "fakenfs":
3522
from bzrlib.tests import test_server
3523
return test_server.FakeNFSServer
3446
from bzrlib.transport.fakenfs import FakeNFSServer
3447
return FakeNFSServer
3524
3448
msg = "No known transport type %s. Supported types are: sftp\n" %\
3525
3449
(typestring)
3526
3450
raise errors.BzrCommandError(msg)
3537
3461
'throughout the test suite.',
3538
3462
type=get_transport_type),
3539
3463
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.',
3541
hidden=True),
3464
help='Run the benchmarks rather than selftests.'),
3542
3465
Option('lsprof-timed',
3543
3466
help='Generate lsprof output for benchmarked'
3544
3467
' sections of code.'),
3545
3468
Option('lsprof-tests',
3546
3469
help='Generate lsprof output for each test.'),
3470
Option('cache-dir', type=str,
3471
help='Cache intermediate benchmark output in this '
3472
'directory.'),
3547
3473
Option('first',
3548
3474
help='Run all tests, but run specified tests first.',
3549
3475
short_name='f',
3583
3509
3584
3510
def run(self, testspecs_list=None, verbose=False, one=False,
3585
3511
transport=None, benchmark=None,
3586
lsprof_timed=None,
3512
lsprof_timed=None, cache_dir=None,
3587
3513
first=False, list_only=False,
3588
3514
randomize=None, exclude=None, strict=False,
3589
3515
load_list=None, debugflag=None, starting_with=None, subunit=False,
3590
3516
parallel=None, lsprof_tests=False):
3591
3517
from bzrlib.tests import selftest
3518
import bzrlib.benchmarks as benchmarks
3519
from bzrlib.benchmarks import tree_creator
3592
3520
3593
3521
# Make deprecation warnings visible, unless -Werror is set
3594
3522
symbol_versioning.activate_deprecation_warnings(override=False)
3595
3523
3524
if cache_dir is not None:
3525
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3596
3526
if testspecs_list is not None:
3597
3527
pattern = '|'.join(testspecs_list)
3598
3528
else:
3604
3534
raise errors.BzrCommandError("subunit not available. subunit "
3605
3535
"needs to be installed to use --subunit.")
3606
3536
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3607
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3608
# stdout, which would corrupt the subunit stream.
3609
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3610
# following code can be deleted when it's sufficiently deployed
3611
# -- vila/mgz 20100514
3612
if (sys.platform == "win32"
3613
and getattr(sys.stdout, 'fileno', None) is not None):
3614
import msvcrt
3615
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3616
3537
if parallel:
3617
3538
self.additional_selftest_args.setdefault(
3618
3539
'suite_decorators', []).append(parallel)
3619
3540
if benchmark:
3620
raise errors.BzrCommandError(
3621
"--benchmark is no longer supported from bzr 2.2; "
3622
"use bzr-usertest instead")
3623
test_suite_factory = None
3624
selftest_kwargs = {"verbose": verbose,
3625
"pattern": pattern,
3626
"stop_on_failure": one,
3627
"transport": transport,
3628
"test_suite_factory": test_suite_factory,
3629
"lsprof_timed": lsprof_timed,
3630
"lsprof_tests": lsprof_tests,
3631
"matching_tests_first": first,
3632
"list_only": list_only,
3633
"random_seed": randomize,
3634
"exclude_pattern": exclude,
3635
"strict": strict,
3636
"load_list": load_list,
3637
"debug_flags": debugflag,
3638
"starting_with": starting_with
3639
}
3640
selftest_kwargs.update(self.additional_selftest_args)
3641
result = selftest(**selftest_kwargs)
3541
test_suite_factory = benchmarks.test_suite
3542
# Unless user explicitly asks for quiet, be verbose in benchmarks
3543
verbose = not is_quiet()
3544
# TODO: should possibly lock the history file...
3545
benchfile = open(".perf_history", "at", buffering=1)
3546
else:
3547
test_suite_factory = None
3548
benchfile = None
3549
try:
3550
selftest_kwargs = {"verbose": verbose,
3551
"pattern": pattern,
3552
"stop_on_failure": one,
3553
"transport": transport,
3554
"test_suite_factory": test_suite_factory,
3555
"lsprof_timed": lsprof_timed,
3556
"lsprof_tests": lsprof_tests,
3557
"bench_history": benchfile,
3558
"matching_tests_first": first,
3559
"list_only": list_only,
3560
"random_seed": randomize,
3561
"exclude_pattern": exclude,
3562
"strict": strict,
3563
"load_list": load_list,
3564
"debug_flags": debugflag,
3565
"starting_with": starting_with
3566
}
3567
selftest_kwargs.update(self.additional_selftest_args)
3568
result = selftest(**selftest_kwargs)
3569
finally:
3570
if benchfile is not None:
3571
benchfile.close()
3642
3572
return int(not result)
3643
3573
3644
3574
3645
3575
class cmd_version(Command):
3646
__doc__ = """Show version of bzr."""
3576
"""Show version of bzr."""
3647
3577
3648
3578
encoding_type = 'replace'
3649
3579
takes_options = [
3660
3590
3661
3591
3662
3592
class cmd_rocks(Command):
3663
__doc__ = """Statement of optimism."""
3593
"""Statement of optimism."""
3664
3594
3665
3595
hidden = True
3666
3596
3667
3597
@display_command
3668
3598
def run(self):
3669
self.outf.write("It sure does!\n")
3599
print "It sure does!"
3670
3600
3671
3601
3672
3602
class cmd_find_merge_base(Command):
3673
__doc__ = """Find and print a base revision for merging two branches."""
3603
"""Find and print a base revision for merging two branches."""
3674
3604
# TODO: Options to specify revisions on either side, as if
3675
3605
# merging only part of the history.
3676
3606
takes_args = ['branch', 'other']
3682
3612
3683
3613
branch1 = Branch.open_containing(branch)[0]
3684
3614
branch2 = Branch.open_containing(other)[0]
3685
self.add_cleanup(branch1.lock_read().unlock)
3686
self.add_cleanup(branch2.lock_read().unlock)
3687
last1 = ensure_null(branch1.last_revision())
3688
last2 = ensure_null(branch2.last_revision())
3689
3690
graph = branch1.repository.get_graph(branch2.repository)
3691
base_rev_id = graph.find_unique_lca(last1, last2)
3692
3693
self.outf.write('merge base is revision %s\n' % base_rev_id)
3615
branch1.lock_read()
3616
try:
3617
branch2.lock_read()
3618
try:
3619
last1 = ensure_null(branch1.last_revision())
3620
last2 = ensure_null(branch2.last_revision())
3621
3622
graph = branch1.repository.get_graph(branch2.repository)
3623
base_rev_id = graph.find_unique_lca(last1, last2)
3624
3625
print 'merge base is revision %s' % base_rev_id
3626
finally:
3627
branch2.unlock()
3628
finally:
3629
branch1.unlock()
3694
3630
3695
3631
3696
3632
class cmd_merge(Command):
3697
__doc__ = """Perform a three-way merge.
3633
"""Perform a three-way merge.
3698
3634
3699
3635
The source of the merge can be specified either in the form of a branch,
3700
3636
or in the form of a path to a file containing a merge directive generated
3729
3665
committed to record the result of the merge.
3730
3666
3731
3667
merge refuses to run if there are any uncommitted changes, unless
3732
--force is given. The --force option can also be used to create a
3733
merge revision which has more than two parents.
3734
3735
If one would like to merge changes from the working tree of the other
3736
branch without merging any committed revisions, the --uncommitted option
3737
can be given.
3668
--force is given.
3738
3669
3739
3670
To select only some changes to merge, use "merge -i", which will prompt
3740
3671
you to apply each diff hunk and file change, similar to "shelve".
3755
3686
To apply a merge directive contained in /tmp/merge::
3756
3687
3757
3688
bzr merge /tmp/merge
3758
3759
To create a merge revision with three parents from two branches
3760
feature1a and feature1b:
3761
3762
bzr merge ../feature1a
3763
bzr merge ../feature1b --force
3764
bzr commit -m 'revision with three parents'
3765
3689
"""
3766
3690
3767
3691
encoding_type = 'exact'
3783
3707
' completely merged into the source, pull from the'
3784
3708
' source rather than merging. When this happens,'
3785
3709
' you do not need to commit the result.'),
3786
custom_help('directory',
3710
Option('directory',
3787
3711
help='Branch to merge into, '
3788
'rather than the one containing the working directory.'),
3712
'rather than the one containing the working directory.',
3713
short_name='d',
3714
type=unicode,
3715
),
3789
3716
Option('preview', help='Instead of merging, show a diff of the'
3790
3717
' merge.'),
3791
3718
Option('interactive', help='Select changes interactively.',
3822
3749
view_info = _get_view_info_for_change_reporter(tree)
3823
3750
change_reporter = delta._ChangeReporter(
3824
3751
unversioned_filter=tree.is_ignored, view_info=view_info)
3825
pb = ui.ui_factory.nested_progress_bar()
3826
self.add_cleanup(pb.finished)
3827
self.add_cleanup(tree.lock_write().unlock)
3828
if location is not None:
3829
try:
3830
mergeable = bundle.read_mergeable_from_url(location,
3831
possible_transports=possible_transports)
3832
except errors.NotABundle:
3833
mergeable = None
3752
cleanups = []
3753
try:
3754
pb = ui.ui_factory.nested_progress_bar()
3755
cleanups.append(pb.finished)
3756
tree.lock_write()
3757
cleanups.append(tree.unlock)
3758
if location is not None:
3759
try:
3760
mergeable = bundle.read_mergeable_from_url(location,
3761
possible_transports=possible_transports)
3762
except errors.NotABundle:
3763
mergeable = None
3764
else:
3765
if uncommitted:
3766
raise errors.BzrCommandError('Cannot use --uncommitted'
3767
' with bundles or merge directives.')
3768
3769
if revision is not None:
3770
raise errors.BzrCommandError(
3771
'Cannot use -r with merge directives or bundles')
3772
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3773
mergeable, pb)
3774
3775
if merger is None and uncommitted:
3776
if revision is not None and len(revision) > 0:
3777
raise errors.BzrCommandError('Cannot use --uncommitted and'
3778
' --revision at the same time.')
3779
merger = self.get_merger_from_uncommitted(tree, location, pb,
3780
cleanups)
3781
allow_pending = False
3782
3783
if merger is None:
3784
merger, allow_pending = self._get_merger_from_branch(tree,
3785
location, revision, remember, possible_transports, pb)
3786
3787
merger.merge_type = merge_type
3788
merger.reprocess = reprocess
3789
merger.show_base = show_base
3790
self.sanity_check_merger(merger)
3791
if (merger.base_rev_id == merger.other_rev_id and
3792
merger.other_rev_id is not None):
3793
note('Nothing to do.')
3794
return 0
3795
if pull:
3796
if merger.interesting_files is not None:
3797
raise errors.BzrCommandError('Cannot pull individual files')
3798
if (merger.base_rev_id == tree.last_revision()):
3799
result = tree.pull(merger.other_branch, False,
3800
merger.other_rev_id)
3801
result.report(self.outf)
3802
return 0
3803
if merger.this_basis is None:
3804
raise errors.BzrCommandError(
3805
"This branch has no commits."
3806
" (perhaps you would prefer 'bzr pull')")
3807
if preview:
3808
return self._do_preview(merger, cleanups)
3809
elif interactive:
3810
return self._do_interactive(merger, cleanups)
3834
3811
else:
3835
if uncommitted:
3836
raise errors.BzrCommandError('Cannot use --uncommitted'
3837
' with bundles or merge directives.')
3838
3839
if revision is not None:
3840
raise errors.BzrCommandError(
3841
'Cannot use -r with merge directives or bundles')
3842
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3843
mergeable, None)
3844
3845
if merger is None and uncommitted:
3846
if revision is not None and len(revision) > 0:
3847
raise errors.BzrCommandError('Cannot use --uncommitted and'
3848
' --revision at the same time.')
3849
merger = self.get_merger_from_uncommitted(tree, location, None)
3850
allow_pending = False
3851
3852
if merger is None:
3853
merger, allow_pending = self._get_merger_from_branch(tree,
3854
location, revision, remember, possible_transports, None)
3855
3856
merger.merge_type = merge_type
3857
merger.reprocess = reprocess
3858
merger.show_base = show_base
3859
self.sanity_check_merger(merger)
3860
if (merger.base_rev_id == merger.other_rev_id and
3861
merger.other_rev_id is not None):
3862
note('Nothing to do.')
3863
return 0
3864
if pull:
3865
if merger.interesting_files is not None:
3866
raise errors.BzrCommandError('Cannot pull individual files')
3867
if (merger.base_rev_id == tree.last_revision()):
3868
result = tree.pull(merger.other_branch, False,
3869
merger.other_rev_id)
3870
result.report(self.outf)
3871
return 0
3872
if merger.this_basis is None:
3873
raise errors.BzrCommandError(
3874
"This branch has no commits."
3875
" (perhaps you would prefer 'bzr pull')")
3876
if preview:
3877
return self._do_preview(merger)
3878
elif interactive:
3879
return self._do_interactive(merger)
3880
else:
3881
return self._do_merge(merger, change_reporter, allow_pending,
3882
verified)
3883
3884
def _get_preview(self, merger):
3812
return self._do_merge(merger, change_reporter, allow_pending,
3813
verified)
3814
finally:
3815
for cleanup in reversed(cleanups):
3816
cleanup()
3817
3818
def _get_preview(self, merger, cleanups):
3885
3819
tree_merger = merger.make_merger()
3886
3820
tt = tree_merger.make_preview_transform()
3887
self.add_cleanup(tt.finalize)
3821
cleanups.append(tt.finalize)
3888
3822
result_tree = tt.get_preview_tree()
3889
3823
return result_tree
3890
3824
3891
def _do_preview(self, merger):
3825
def _do_preview(self, merger, cleanups):
3892
3826
from bzrlib.diff import show_diff_trees
3893
result_tree = self._get_preview(merger)
3894
path_encoding = osutils.get_diff_header_encoding()
3827
result_tree = self._get_preview(merger, cleanups)
3895
3828
show_diff_trees(merger.this_tree, result_tree, self.outf,
3896
old_label='', new_label='',
3897
path_encoding=path_encoding)
3829
old_label='', new_label='')
3898
3830
3899
3831
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3900
3832
merger.change_reporter = change_reporter
3908
3840
else:
3909
3841
return 0
3910
3842
3911
def _do_interactive(self, merger):
3843
def _do_interactive(self, merger, cleanups):
3912
3844
"""Perform an interactive merge.
3913
3845
3914
3846
This works by generating a preview tree of the merge, then using
3916
3848
and the preview tree.
3917
3849
"""
3918
3850
from bzrlib import shelf_ui
3919
result_tree = self._get_preview(merger)
3851
result_tree = self._get_preview(merger, cleanups)
3920
3852
writer = bzrlib.option.diff_writer_registry.get()
3921
3853
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3922
3854
reporter=shelf_ui.ApplyReporter(),
3990
3922
allow_pending = True
3991
3923
return merger, allow_pending
3992
3924
3993
def get_merger_from_uncommitted(self, tree, location, pb):
3925
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
3994
3926
"""Get a merger for uncommitted changes.
3995
3927
3996
3928
:param tree: The tree the merger should apply to.
3997
3929
:param location: The location containing uncommitted changes.
3998
3930
:param pb: The progress bar to use for showing progress.
3931
:param cleanups: A list of operations to perform to clean up the
3932
temporary directories, unfinalized objects, etc.
3999
3933
"""
4000
3934
location = self._select_branch_location(tree, location)[0]
4001
3935
other_tree, other_path = WorkingTree.open_containing(location)
4053
3987
4054
3988
4055
3989
class cmd_remerge(Command):
4056
__doc__ = """Redo a merge.
3990
"""Redo a merge.
4057
3991
4058
3992
Use this if you want to try a different merge technique while resolving
4059
3993
conflicts. Some merge techniques are better than others, and remerge
4084
4018
4085
4019
def run(self, file_list=None, merge_type=None, show_base=False,
4086
4020
reprocess=False):
4087
from bzrlib.conflicts import restore
4088
4021
if merge_type is None:
4089
4022
merge_type = _mod_merge.Merge3Merger
4090
4023
tree, file_list = tree_files(file_list)
4091
self.add_cleanup(tree.lock_write().unlock)
4092
parents = tree.get_parent_ids()
4093
if len(parents) != 2:
4094
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4095
" merges. Not cherrypicking or"
4096
" multi-merges.")
4097
repository = tree.branch.repository
4098
interesting_ids = None
4099
new_conflicts = []
4100
conflicts = tree.conflicts()
4101
if file_list is not None:
4102
interesting_ids = set()
4103
for filename in file_list:
4104
file_id = tree.path2id(filename)
4105
if file_id is None:
4106
raise errors.NotVersionedError(filename)
4107
interesting_ids.add(file_id)
4108
if tree.kind(file_id) != "directory":
4109
continue
4024
tree.lock_write()
4025
try:
4026
parents = tree.get_parent_ids()
4027
if len(parents) != 2:
4028
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4029
" merges. Not cherrypicking or"
4030
" multi-merges.")
4031
repository = tree.branch.repository
4032
interesting_ids = None
4033
new_conflicts = []
4034
conflicts = tree.conflicts()
4035
if file_list is not None:
4036
interesting_ids = set()
4037
for filename in file_list:
4038
file_id = tree.path2id(filename)
4039
if file_id is None:
4040
raise errors.NotVersionedError(filename)
4041
interesting_ids.add(file_id)
4042
if tree.kind(file_id) != "directory":
4043
continue
4110
4044
4111
for name, ie in tree.inventory.iter_entries(file_id):
4112
interesting_ids.add(ie.file_id)
4113
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4114
else:
4115
# Remerge only supports resolving contents conflicts
4116
allowed_conflicts = ('text conflict', 'contents conflict')
4117
restore_files = [c.path for c in conflicts
4118
if c.typestring in allowed_conflicts]
4119
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4120
tree.set_conflicts(ConflictList(new_conflicts))
4121
if file_list is not None:
4122
restore_files = file_list
4123
for filename in restore_files:
4045
for name, ie in tree.inventory.iter_entries(file_id):
4046
interesting_ids.add(ie.file_id)
4047
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4048
else:
4049
# Remerge only supports resolving contents conflicts
4050
allowed_conflicts = ('text conflict', 'contents conflict')
4051
restore_files = [c.path for c in conflicts
4052
if c.typestring in allowed_conflicts]
4053
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4054
tree.set_conflicts(ConflictList(new_conflicts))
4055
if file_list is not None:
4056
restore_files = file_list
4057
for filename in restore_files:
4058
try:
4059
restore(tree.abspath(filename))
4060
except errors.NotConflicted:
4061
pass
4062
# Disable pending merges, because the file texts we are remerging
4063
# have not had those merges performed. If we use the wrong parents
4064
# list, we imply that the working tree text has seen and rejected
4065
# all the changes from the other tree, when in fact those changes
4066
# have not yet been seen.
4067
pb = ui.ui_factory.nested_progress_bar()
4068
tree.set_parent_ids(parents[:1])
4124
4069
try:
4125
restore(tree.abspath(filename))
4126
except errors.NotConflicted:
4127
pass
4128
# Disable pending merges, because the file texts we are remerging
4129
# have not had those merges performed. If we use the wrong parents
4130
# list, we imply that the working tree text has seen and rejected
4131
# all the changes from the other tree, when in fact those changes
4132
# have not yet been seen.
4133
tree.set_parent_ids(parents[:1])
4134
try:
4135
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4136
merger.interesting_ids = interesting_ids
4137
merger.merge_type = merge_type
4138
merger.show_base = show_base
4139
merger.reprocess = reprocess
4140
conflicts = merger.do_merge()
4070
merger = _mod_merge.Merger.from_revision_ids(pb,
4071
tree, parents[1])
4072
merger.interesting_ids = interesting_ids
4073
merger.merge_type = merge_type
4074
merger.show_base = show_base
4075
merger.reprocess = reprocess
4076
conflicts = merger.do_merge()
4077
finally:
4078
tree.set_parent_ids(parents)
4079
pb.finished()
4141
4080
finally:
4142
tree.set_parent_ids(parents)
4081
tree.unlock()
4143
4082
if conflicts > 0:
4144
4083
return 1
4145
4084
else:
4147
4086
4148
4087
4149
4088
class cmd_revert(Command):
4150
__doc__ = """Revert files to a previous revision.
4089
"""Revert files to a previous revision.
4151
4090
4152
4091
Giving a list of files will revert only those files. Otherwise, all files
4153
4092
will be reverted. If the revision is not specified with '--revision', the
4172
4111
created as above. Directories containing unknown files will not be
4173
4112
deleted.
4174
4113
4175
The working tree contains a list of revisions that have been merged but
4176
not yet committed. These revisions will be included as additional parents
4177
of the next commit. Normally, using revert clears that list as well as
4178
reverting the files. If any files are specified, revert leaves the list
4179
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4180
.`` in the tree root to revert all files but keep the recorded merges,
4181
and ``bzr revert --forget-merges`` to clear the pending merge list without
4114
The working tree contains a list of pending merged revisions, which will
4115
be included as parents in the next commit. Normally, revert clears that
4116
list as well as reverting the files. If any files are specified, revert
4117
leaves the pending merge list alone and reverts only the files. Use "bzr
4118
revert ." in the tree root to revert all files but keep the merge record,
4119
and "bzr revert --forget-merges" to clear the pending merge list without
4182
4120
reverting any files.
4183
4121
4184
Using "bzr revert --forget-merges", it is possible to apply all of the
4185
changes from a branch in a single revision. To do this, perform the merge
4186
as desired. Then doing revert with the "--forget-merges" option will keep
4187
the content of the tree as it was, but it will clear the list of pending
4188
merges. The next commit will then contain all of the changes that are
4189
present in the other branch, but without any other parent revisions.
4190
Because this technique forgets where these changes originated, it may
4191
cause additional conflicts on later merges involving the same source and
4122
Using "bzr revert --forget-merges", it is possible to apply the changes
4123
from an arbitrary merge as a single revision. To do this, perform the
4124
merge as desired. Then doing revert with the "--forget-merges" option will
4125
keep the content of the tree as it was, but it will clear the list of
4126
pending merges. The next commit will then contain all of the changes that
4127
would have been in the merge, but without any mention of the other parent
4128
revisions. Because this technique forgets where these changes originated,
4129
it may cause additional conflicts on later merges involving the source and
4192
4130
target branches.
4193
4131
"""
4194
4132
4204
4142
def run(self, revision=None, no_backup=False, file_list=None,
4205
4143
forget_merges=None):
4206
4144
tree, file_list = tree_files(file_list)
4207
self.add_cleanup(tree.lock_tree_write().unlock)
4208
if forget_merges:
4209
tree.set_parent_ids(tree.get_parent_ids()[:1])
4210
else:
4211
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4145
tree.lock_write()
4146
try:
4147
if forget_merges:
4148
tree.set_parent_ids(tree.get_parent_ids()[:1])
4149
else:
4150
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4151
finally:
4152
tree.unlock()
4212
4153
4213
4154
@staticmethod
4214
4155
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4215
4156
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4216
tree.revert(file_list, rev_tree, not no_backup, None,
4217
report_changes=True)
4157
pb = ui.ui_factory.nested_progress_bar()
4158
try:
4159
tree.revert(file_list, rev_tree, not no_backup, pb,
4160
report_changes=True)
4161
finally:
4162
pb.finished()
4218
4163
4219
4164
4220
4165
class cmd_assert_fail(Command):
4221
__doc__ = """Test reporting of assertion failures"""
4166
"""Test reporting of assertion failures"""
4222
4167
# intended just for use in testing
4223
4168
4224
4169
hidden = True
4228
4173
4229
4174
4230
4175
class cmd_help(Command):
4231
__doc__ = """Show help on a command or other topic.
4176
"""Show help on a command or other topic.
4232
4177
"""
4233
4178
4234
4179
_see_also = ['topics']
4247
4192
4248
4193
4249
4194
class cmd_shell_complete(Command):
4250
__doc__ = """Show appropriate completions for context.
4195
"""Show appropriate completions for context.
4251
4196
4252
4197
For a list of all available commands, say 'bzr shell-complete'.
4253
4198
"""
4262
4207
4263
4208
4264
4209
class cmd_missing(Command):
4265
__doc__ = """Show unmerged/unpulled revisions between two branches.
4210
"""Show unmerged/unpulled revisions between two branches.
4266
4211
4267
4212
OTHER_BRANCH may be local or remote.
4268
4213
4299
4244
_see_also = ['merge', 'pull']
4300
4245
takes_args = ['other_branch?']
4301
4246
takes_options = [
4302
'directory',
4303
4247
Option('reverse', 'Reverse the order of revisions.'),
4304
4248
Option('mine-only',
4305
4249
'Display changes in the local branch only.'),
4327
4271
theirs_only=False,
4328
4272
log_format=None, long=False, short=False, line=False,
4329
4273
show_ids=False, verbose=False, this=False, other=False,
4330
include_merges=False, revision=None, my_revision=None,
4331
directory=u'.'):
4274
include_merges=False, revision=None, my_revision=None):
4332
4275
from bzrlib.missing import find_unmerged, iter_log_revisions
4333
4276
def message(s):
4334
4277
if not is_quiet():
4347
4290
elif theirs_only:
4348
4291
restrict = 'remote'
4349
4292
4350
local_branch = Branch.open_containing(directory)[0]
4351
self.add_cleanup(local_branch.lock_read().unlock)
4352
4293
local_branch = Branch.open_containing(u".")[0]
4353
4294
parent = local_branch.get_parent()
4354
4295
if other_branch is None:
4355
4296
other_branch = parent
4364
4305
remote_branch = Branch.open(other_branch)
4365
4306
if remote_branch.base == local_branch.base:
4366
4307
remote_branch = local_branch
4367
else:
4368
self.add_cleanup(remote_branch.lock_read().unlock)
4369
4308
4370
4309
local_revid_range = _revision_range_to_revid_range(
4371
4310
_get_revision_range(my_revision, local_branch,
4375
4314
_get_revision_range(revision,
4376
4315
remote_branch, self.name()))
4377
4316
4378
local_extra, remote_extra = find_unmerged(
4379
local_branch, remote_branch, restrict,
4380
backward=not reverse,
4381
include_merges=include_merges,
4382
local_revid_range=local_revid_range,
4383
remote_revid_range=remote_revid_range)
4384
4385
if log_format is None:
4386
registry = log.log_formatter_registry
4387
log_format = registry.get_default(local_branch)
4388
lf = log_format(to_file=self.outf,
4389
show_ids=show_ids,
4390
show_timezone='original')
4391
4392
status_code = 0
4393
if local_extra and not theirs_only:
4394
message("You have %d extra revision(s):\n" %
4395
len(local_extra))
4396
for revision in iter_log_revisions(local_extra,
4397
local_branch.repository,
4398
verbose):
4399
lf.log_revision(revision)
4400
printed_local = True
4401
status_code = 1
4402
else:
4403
printed_local = False
4404
4405
if remote_extra and not mine_only:
4406
if printed_local is True:
4407
message("\n\n\n")
4408
message("You are missing %d revision(s):\n" %
4409
len(remote_extra))
4410
for revision in iter_log_revisions(remote_extra,
4411
remote_branch.repository,
4412
verbose):
4413
lf.log_revision(revision)
4414
status_code = 1
4415
4416
if mine_only and not local_extra:
4417
# We checked local, and found nothing extra
4418
message('This branch is up to date.\n')
4419
elif theirs_only and not remote_extra:
4420
# We checked remote, and found nothing extra
4421
message('Other branch is up to date.\n')
4422
elif not (mine_only or theirs_only or local_extra or
4423
remote_extra):
4424
# We checked both branches, and neither one had extra
4425
# revisions
4426
message("Branches are up to date.\n")
4427
self.cleanup_now()
4317
local_branch.lock_read()
4318
try:
4319
remote_branch.lock_read()
4320
try:
4321
local_extra, remote_extra = find_unmerged(
4322
local_branch, remote_branch, restrict,
4323
backward=not reverse,
4324
include_merges=include_merges,
4325
local_revid_range=local_revid_range,
4326
remote_revid_range=remote_revid_range)
4327
4328
if log_format is None:
4329
registry = log.log_formatter_registry
4330
log_format = registry.get_default(local_branch)
4331
lf = log_format(to_file=self.outf,
4332
show_ids=show_ids,
4333
show_timezone='original')
4334
4335
status_code = 0
4336
if local_extra and not theirs_only:
4337
message("You have %d extra revision(s):\n" %
4338
len(local_extra))
4339
for revision in iter_log_revisions(local_extra,
4340
local_branch.repository,
4341
verbose):
4342
lf.log_revision(revision)
4343
printed_local = True
4344
status_code = 1
4345
else:
4346
printed_local = False
4347
4348
if remote_extra and not mine_only:
4349
if printed_local is True:
4350
message("\n\n\n")
4351
message("You are missing %d revision(s):\n" %
4352
len(remote_extra))
4353
for revision in iter_log_revisions(remote_extra,
4354
remote_branch.repository,
4355
verbose):
4356
lf.log_revision(revision)
4357
status_code = 1
4358
4359
if mine_only and not local_extra:
4360
# We checked local, and found nothing extra
4361
message('This branch is up to date.\n')
4362
elif theirs_only and not remote_extra:
4363
# We checked remote, and found nothing extra
4364
message('Other branch is up to date.\n')
4365
elif not (mine_only or theirs_only or local_extra or
4366
remote_extra):
4367
# We checked both branches, and neither one had extra
4368
# revisions
4369
message("Branches are up to date.\n")
4370
finally:
4371
remote_branch.unlock()
4372
finally:
4373
local_branch.unlock()
4428
4374
if not status_code and parent is None and other_branch is not None:
4429
self.add_cleanup(local_branch.lock_write().unlock)
4430
# handle race conditions - a parent might be set while we run.
4431
if local_branch.get_parent() is None:
4432
local_branch.set_parent(remote_branch.base)
4375
local_branch.lock_write()
4376
try:
4377
# handle race conditions - a parent might be set while we run.
4378
if local_branch.get_parent() is None:
4379
local_branch.set_parent(remote_branch.base)
4380
finally:
4381
local_branch.unlock()
4433
4382
return status_code
4434
4383
4435
4384
4436
4385
class cmd_pack(Command):
4437
__doc__ = """Compress the data within a repository.
4438
4439
This operation compresses the data within a bazaar repository. As
4440
bazaar supports automatic packing of repository, this operation is
4441
normally not required to be done manually.
4442
4443
During the pack operation, bazaar takes a backup of existing repository
4444
data, i.e. pack files. This backup is eventually removed by bazaar
4445
automatically when it is safe to do so. To save disk space by removing
4446
the backed up pack files, the --clean-obsolete-packs option may be
4447
used.
4448
4449
Warning: If you use --clean-obsolete-packs and your machine crashes
4450
during or immediately after repacking, you may be left with a state
4451
where the deletion has been written to disk but the new packs have not
4452
been. In this case the repository may be unusable.
4453
"""
4386
"""Compress the data within a repository."""
4454
4387
4455
4388
_see_also = ['repositories']
4456
4389
takes_args = ['branch_or_repo?']
4457
takes_options = [
4458
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4459
]
4460
4390
4461
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4391
def run(self, branch_or_repo='.'):
4462
4392
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4463
4393
try:
4464
4394
branch = dir.open_branch()
4465
4395
repository = branch.repository
4466
4396
except errors.NotBranchError:
4467
4397
repository = dir.open_repository()
4468
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4398
repository.pack()
4469
4399
4470
4400
4471
4401
class cmd_plugins(Command):
4472
__doc__ = """List the installed plugins.
4402
"""List the installed plugins.
4473
4403
4474
4404
This command displays the list of installed plugins including
4475
4405
version of plugin and a short description of each.
4482
4412
adding new commands, providing additional network transports and
4483
4413
customizing log output.
4484
4414
4485
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
4486
for further information on plugins including where to find them and how to
4487
install them. Instructions are also provided there on how to write new
4488
plugins using the Python programming language.
4415
See the Bazaar web site, http://bazaar-vcs.org, for further
4416
information on plugins including where to find them and how to
4417
install them. Instructions are also provided there on how to
4418
write new plugins using the Python programming language.
4489
4419
"""
4490
4420
takes_options = ['verbose']
4491
4421
4506
4436
doc = '(no description)'
4507
4437
result.append((name_ver, doc, plugin.path()))
4508
4438
for name_ver, doc, path in sorted(result):
4509
self.outf.write("%s\n" % name_ver)
4510
self.outf.write(" %s\n" % doc)
4439
print name_ver
4440
print ' ', doc
4511
4441
if verbose:
4512
self.outf.write(" %s\n" % path)
4513
self.outf.write("\n")
4442
print ' ', path
4443
print
4514
4444
4515
4445
4516
4446
class cmd_testament(Command):
4517
__doc__ = """Show testament (signing-form) of a revision."""
4447
"""Show testament (signing-form) of a revision."""
4518
4448
takes_options = [
4519
4449
'revision',
4520
4450
Option('long', help='Produce long-format testament.'),
4532
4462
b = Branch.open_containing(branch)[0]
4533
4463
else:
4534
4464
b = Branch.open(branch)
4535
self.add_cleanup(b.lock_read().unlock)
4536
if revision is None:
4537
rev_id = b.last_revision()
4538
else:
4539
rev_id = revision[0].as_revision_id(b)
4540
t = testament_class.from_revision(b.repository, rev_id)
4541
if long:
4542
sys.stdout.writelines(t.as_text_lines())
4543
else:
4544
sys.stdout.write(t.as_short_text())
4465
b.lock_read()
4466
try:
4467
if revision is None:
4468
rev_id = b.last_revision()
4469
else:
4470
rev_id = revision[0].as_revision_id(b)
4471
t = testament_class.from_revision(b.repository, rev_id)
4472
if long:
4473
sys.stdout.writelines(t.as_text_lines())
4474
else:
4475
sys.stdout.write(t.as_short_text())
4476
finally:
4477
b.unlock()
4545
4478
4546
4479
4547
4480
class cmd_annotate(Command):
4548
__doc__ = """Show the origin of each line in a file.
4481
"""Show the origin of each line in a file.
4549
4482
4550
4483
This prints out the given file with an annotation on the left side
4551
4484
indicating which revision, author and date introduced the change.
4562
4495
Option('long', help='Show commit date in annotations.'),
4563
4496
'revision',
4564
4497
'show-ids',
4565
'directory',
4566
4498
]
4567
4499
encoding_type = 'exact'
4568
4500
4569
4501
@display_command
4570
4502
def run(self, filename, all=False, long=False, revision=None,
4571
show_ids=False, directory=None):
4503
show_ids=False):
4572
4504
from bzrlib.annotate import annotate_file, annotate_file_tree
4573
4505
wt, branch, relpath = \
4574
_open_directory_or_containing_tree_or_branch(filename, directory)
4575
if wt is not None:
4576
self.add_cleanup(wt.lock_read().unlock)
4577
else:
4578
self.add_cleanup(branch.lock_read().unlock)
4579
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4580
self.add_cleanup(tree.lock_read().unlock)
4581
if wt is not None:
4582
file_id = wt.path2id(relpath)
4583
else:
4584
file_id = tree.path2id(relpath)
4585
if file_id is None:
4586
raise errors.NotVersionedError(filename)
4587
file_version = tree.inventory[file_id].revision
4588
if wt is not None and revision is None:
4589
# If there is a tree and we're not annotating historical
4590
# versions, annotate the working tree's content.
4591
annotate_file_tree(wt, file_id, self.outf, long, all,
4592
show_ids=show_ids)
4593
else:
4594
annotate_file(branch, file_version, file_id, long, all, self.outf,
4595
show_ids=show_ids)
4506
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4507
if wt is not None:
4508
wt.lock_read()
4509
else:
4510
branch.lock_read()
4511
try:
4512
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4513
if wt is not None:
4514
file_id = wt.path2id(relpath)
4515
else:
4516
file_id = tree.path2id(relpath)
4517
if file_id is None:
4518
raise errors.NotVersionedError(filename)
4519
file_version = tree.inventory[file_id].revision
4520
if wt is not None and revision is None:
4521
# If there is a tree and we're not annotating historical
4522
# versions, annotate the working tree's content.
4523
annotate_file_tree(wt, file_id, self.outf, long, all,
4524
show_ids=show_ids)
4525
else:
4526
annotate_file(branch, file_version, file_id, long, all, self.outf,
4527
show_ids=show_ids)
4528
finally:
4529
if wt is not None:
4530
wt.unlock()
4531
else:
4532
branch.unlock()
4596
4533
4597
4534
4598
4535
class cmd_re_sign(Command):
4599
__doc__ = """Create a digital signature for an existing revision."""
4536
"""Create a digital signature for an existing revision."""
4600
4537
# TODO be able to replace existing ones.
4601
4538
4602
4539
hidden = True # is this right ?
4603
4540
takes_args = ['revision_id*']
4604
takes_options = ['directory', 'revision']
4541
takes_options = ['revision']
4605
4542
4606
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4543
def run(self, revision_id_list=None, revision=None):
4607
4544
if revision_id_list is not None and revision is not None:
4608
4545
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4609
4546
if revision_id_list is None and revision is None:
4610
4547
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4611
b = WorkingTree.open_containing(directory)[0].branch
4612
self.add_cleanup(b.lock_write().unlock)
4613
return self._run(b, revision_id_list, revision)
4548
b = WorkingTree.open_containing(u'.')[0].branch
4549
b.lock_write()
4550
try:
4551
return self._run(b, revision_id_list, revision)
4552
finally:
4553
b.unlock()
4614
4554
4615
4555
def _run(self, b, revision_id_list, revision):
4616
4556
import bzrlib.gpg as gpg
4661
4601
4662
4602
4663
4603
class cmd_bind(Command):
4664
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4665
If no branch is supplied, rebind to the last bound location.
4604
"""Convert the current branch into a checkout of the supplied branch.
4666
4605
4667
4606
Once converted into a checkout, commits must succeed on the master branch
4668
4607
before they will be applied to the local branch.
4674
4613
4675
4614
_see_also = ['checkouts', 'unbind']
4676
4615
takes_args = ['location?']
4677
takes_options = ['directory']
4616
takes_options = []
4678
4617
4679
def run(self, location=None, directory=u'.'):
4680
b, relpath = Branch.open_containing(directory)
4618
def run(self, location=None):
4619
b, relpath = Branch.open_containing(u'.')
4681
4620
if location is None:
4682
4621
try:
4683
4622
location = b.get_old_bound_location()
4686
4625
'This format does not remember old locations.')
4687
4626
else:
4688
4627
if location is None:
4689
if b.get_bound_location() is not None:
4690
raise errors.BzrCommandError('Branch is already bound')
4691
else:
4692
raise errors.BzrCommandError('No location supplied '
4693
'and no previous location known')
4628
raise errors.BzrCommandError('No location supplied and no '
4629
'previous location known')
4694
4630
b_other = Branch.open(location)
4695
4631
try:
4696
4632
b.bind(b_other)
4702
4638
4703
4639
4704
4640
class cmd_unbind(Command):
4705
__doc__ = """Convert the current checkout into a regular branch.
4641
"""Convert the current checkout into a regular branch.
4706
4642
4707
4643
After unbinding, the local branch is considered independent and subsequent
4708
4644
commits will be local only.
4710
4646
4711
4647
_see_also = ['checkouts', 'bind']
4712
4648
takes_args = []
4713
takes_options = ['directory']
4649
takes_options = []
4714
4650
4715
def run(self, directory=u'.'):
4716
b, relpath = Branch.open_containing(directory)
4651
def run(self):
4652
b, relpath = Branch.open_containing(u'.')
4717
4653
if not b.unbind():
4718
4654
raise errors.BzrCommandError('Local branch is not bound')
4719
4655
4720
4656
4721
4657
class cmd_uncommit(Command):
4722
__doc__ = """Remove the last committed revision.
4658
"""Remove the last committed revision.
4723
4659
4724
4660
--verbose will print out what is being removed.
4725
4661
--dry-run will go through all the motions, but not actually
4765
4701
b = control.open_branch()
4766
4702
4767
4703
if tree is not None:
4768
self.add_cleanup(tree.lock_write().unlock)
4704
tree.lock_write()
4769
4705
else:
4770
self.add_cleanup(b.lock_write().unlock)
4771
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4706
b.lock_write()
4707
try:
4708
return self._run(b, tree, dry_run, verbose, revision, force,
4709
local=local)
4710
finally:
4711
if tree is not None:
4712
tree.unlock()
4713
else:
4714
b.unlock()
4772
4715
4773
4716
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4774
4717
from bzrlib.log import log_formatter, show_log
4806
4749
end_revision=last_revno)
4807
4750
4808
4751
if dry_run:
4809
self.outf.write('Dry-run, pretending to remove'
4810
' the above revisions.\n')
4752
print 'Dry-run, pretending to remove the above revisions.'
4753
if not force:
4754
val = raw_input('Press <enter> to continue')
4811
4755
else:
4812
self.outf.write('The above revision(s) will be removed.\n')
4813
4814
if not force:
4815
if not ui.ui_factory.get_boolean('Are you sure'):
4816
self.outf.write('Canceled')
4817
return 0
4756
print 'The above revision(s) will be removed.'
4757
if not force:
4758
val = raw_input('Are you sure [y/N]? ')
4759
if val.lower() not in ('y', 'yes'):
4760
print 'Canceled'
4761
return 0
4818
4762
4819
4763
mutter('Uncommitting from {%s} to {%s}',
4820
4764
last_rev_id, rev_id)
4821
4765
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4822
4766
revno=revno, local=local)
4823
self.outf.write('You can restore the old tip by running:\n'
4824
' bzr pull . -r revid:%s\n' % last_rev_id)
4767
note('You can restore the old tip by running:\n'
4768
' bzr pull . -r revid:%s', last_rev_id)
4825
4769
4826
4770
4827
4771
class cmd_break_lock(Command):
4828
__doc__ = """Break a dead lock on a repository, branch or working directory.
4772
"""Break a dead lock on a repository, branch or working directory.
4829
4773
4830
4774
CAUTION: Locks should only be broken when you are sure that the process
4831
4775
holding the lock has been stopped.
4832
4776
4833
You can get information on what locks are open via the 'bzr info
4834
[location]' command.
4777
You can get information on what locks are open via the 'bzr info' command.
4835
4778
4836
4779
:Examples:
4837
4780
bzr break-lock
4838
bzr break-lock bzr+ssh://example.com/bzr/foo
4839
4781
"""
4840
4782
takes_args = ['location?']
4841
4783
4850
4792
4851
4793
4852
4794
class cmd_wait_until_signalled(Command):
4853
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4795
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4854
4796
4855
4797
This just prints a line to signal when it is ready, then blocks on stdin.
4856
4798
"""
4864
4806
4865
4807
4866
4808
class cmd_serve(Command):
4867
__doc__ = """Run the bzr server."""
4809
"""Run the bzr server."""
4868
4810
4869
4811
aliases = ['server']
4870
4812
4881
4823
'result in a dynamically allocated port. The default port '
4882
4824
'depends on the protocol.',
4883
4825
type=str),
4884
custom_help('directory',
4885
help='Serve contents of this directory.'),
4826
Option('directory',
4827
help='Serve contents of this directory.',
4828
type=unicode),
4886
4829
Option('allow-writes',
4887
4830
help='By default the server is a readonly server. Supplying '
4888
4831
'--allow-writes enables write access to the contents of '
4915
4858
4916
4859
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4917
4860
protocol=None):
4918
from bzrlib import transport
4861
from bzrlib.transport import get_transport, transport_server_registry
4919
4862
if directory is None:
4920
4863
directory = os.getcwd()
4921
4864
if protocol is None:
4922
protocol = transport.transport_server_registry.get()
4865
protocol = transport_server_registry.get()
4923
4866
host, port = self.get_host_and_port(port)
4924
4867
url = urlutils.local_path_to_url(directory)
4925
4868
if not allow_writes:
4926
4869
url = 'readonly+' + url
4927
t = transport.get_transport(url)
4928
protocol(t, host, port, inet)
4870
transport = get_transport(url)
4871
protocol(transport, host, port, inet)
4929
4872
4930
4873
4931
4874
class cmd_join(Command):
4932
__doc__ = """Combine a tree into its containing tree.
4875
"""Combine a tree into its containing tree.
4933
4876
4934
4877
This command requires the target tree to be in a rich-root format.
4935
4878
4975
4918
4976
4919
4977
4920
class cmd_split(Command):
4978
__doc__ = """Split a subdirectory of a tree into a separate tree.
4921
"""Split a subdirectory of a tree into a separate tree.
4979
4922
4980
4923
This command will produce a target tree in a format that supports
4981
4924
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5001
4944
5002
4945
5003
4946
class cmd_merge_directive(Command):
5004
__doc__ = """Generate a merge directive for auto-merge tools.
4947
"""Generate a merge directive for auto-merge tools.
5005
4948
5006
4949
A directive requests a merge to be performed, and also provides all the
5007
4950
information necessary to do so. This means it must either include a
5024
4967
_see_also = ['send']
5025
4968
5026
4969
takes_options = [
5027
'directory',
5028
4970
RegistryOption.from_kwargs('patch-type',
5029
4971
'The type of patch to include in the directive.',
5030
4972
title='Patch type',
5043
4985
encoding_type = 'exact'
5044
4986
5045
4987
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5046
sign=False, revision=None, mail_to=None, message=None,
5047
directory=u'.'):
4988
sign=False, revision=None, mail_to=None, message=None):
5048
4989
from bzrlib.revision import ensure_null, NULL_REVISION
5049
4990
include_patch, include_bundle = {
5050
4991
'plain': (False, False),
5051
4992
'diff': (True, False),
5052
4993
'bundle': (True, True),
5053
4994
}[patch_type]
5054
branch = Branch.open(directory)
4995
branch = Branch.open('.')
5055
4996
stored_submit_branch = branch.get_submit_branch()
5056
4997
if submit_branch is None:
5057
4998
submit_branch = stored_submit_branch
5102
5043
5103
5044
5104
5045
class cmd_send(Command):
5105
__doc__ = """Mail or create a merge-directive for submitting changes.
5046
"""Mail or create a merge-directive for submitting changes.
5106
5047
5107
5048
A merge directive provides many things needed for requesting merges:
5108
5049
5114
5055
directly from the merge directive, without retrieving data from a
5115
5056
branch.
5116
5057
5117
`bzr send` creates a compact data set that, when applied using bzr
5118
merge, has the same effect as merging from the source branch.
5119
5120
By default the merge directive is self-contained and can be applied to any
5121
branch containing submit_branch in its ancestory without needing access to
5122
the source branch.
5123
5124
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5125
revisions, but only a structured request to merge from the
5126
public_location. In that case the public_branch is needed and it must be
5127
up-to-date and accessible to the recipient. The public_branch is always
5128
included if known, so that people can check it later.
5129
5130
The submit branch defaults to the parent of the source branch, but can be
5131
overridden. Both submit branch and public branch will be remembered in
5132
branch.conf the first time they are used for a particular branch. The
5133
source branch defaults to that containing the working directory, but can
5134
be changed using --from.
5135
5136
In order to calculate those changes, bzr must analyse the submit branch.
5137
Therefore it is most efficient for the submit branch to be a local mirror.
5138
If a public location is known for the submit_branch, that location is used
5139
in the merge directive.
5140
5141
The default behaviour is to send the merge directive by mail, unless -o is
5142
given, in which case it is sent to a file.
5058
If --no-bundle is specified, then public_branch is needed (and must be
5059
up-to-date), so that the receiver can perform the merge using the
5060
public_branch. The public_branch is always included if known, so that
5061
people can check it later.
5062
5063
The submit branch defaults to the parent, but can be overridden. Both
5064
submit branch and public branch will be remembered if supplied.
5065
5066
If a public_branch is known for the submit_branch, that public submit
5067
branch is used in the merge instructions. This means that a local mirror
5068
can be used as your actual submit branch, once you have set public_branch
5069
for that mirror.
5143
5070
5144
5071
Mail is sent using your preferred mail program. This should be transparent
5145
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5072
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5146
5073
If the preferred client can't be found (or used), your editor will be used.
5147
5074
5148
5075
To use a specific mail program, set the mail_client configuration option.
5165
5092
5166
5093
The merge directives created by bzr send may be applied using bzr merge or
5167
5094
bzr pull by specifying a file containing a merge directive as the location.
5168
5169
bzr send makes extensive use of public locations to map local locations into
5170
URLs that can be used by other people. See `bzr help configuration` to
5171
set them, and use `bzr info` to display them.
5172
5095
"""
5173
5096
5174
5097
encoding_type = 'exact'
5190
5113
short_name='f',
5191
5114
type=unicode),
5192
5115
Option('output', short_name='o',
5193
help='Write merge directive to this file or directory; '
5116
help='Write merge directive to this file; '
5194
5117
'use - for stdout.',
5195
5118
type=unicode),
5196
5119
Option('strict',
5219
5142
5220
5143
5221
5144
class cmd_bundle_revisions(cmd_send):
5222
__doc__ = """Create a merge-directive for submitting changes.
5145
"""Create a merge-directive for submitting changes.
5223
5146
5224
5147
A merge directive provides many things needed for requesting merges:
5225
5148
5292
5215
5293
5216
5294
5217
class cmd_tag(Command):
5295
__doc__ = """Create, remove or modify a tag naming a revision.
5218
"""Create, remove or modify a tag naming a revision.
5296
5219
5297
5220
Tags give human-meaningful names to revisions. Commands that take a -r
5298
5221
(--revision) option can be given -rtag:X, where X is any previously
5306
5229
5307
5230
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5308
5231
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5309
5310
If no tag name is specified it will be determined through the
5311
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5312
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5313
details.
5314
5232
"""
5315
5233
5316
5234
_see_also = ['commit', 'tags']
5317
takes_args = ['tag_name?']
5235
takes_args = ['tag_name']
5318
5236
takes_options = [
5319
5237
Option('delete',
5320
5238
help='Delete this tag rather than placing it.',
5321
5239
),
5322
custom_help('directory',
5323
help='Branch in which to place the tag.'),
5240
Option('directory',
5241
help='Branch in which to place the tag.',
5242
short_name='d',
5243
type=unicode,
5244
),
5324
5245
Option('force',
5325
5246
help='Replace existing tags.',
5326
5247
),
5327
5248
'revision',
5328
5249
]
5329
5250
5330
def run(self, tag_name=None,
5251
def run(self, tag_name,
5331
5252
delete=None,
5332
5253
directory='.',
5333
5254
force=None,
5334
5255
revision=None,
5335
5256
):
5336
5257
branch, relpath = Branch.open_containing(directory)
5337
self.add_cleanup(branch.lock_write().unlock)
5338
if delete:
5339
if tag_name is None:
5340
raise errors.BzrCommandError("No tag specified to delete.")
5341
branch.tags.delete_tag(tag_name)
5342
self.outf.write('Deleted tag %s.\n' % tag_name)
5343
else:
5344
if revision:
5345
if len(revision) != 1:
5346
raise errors.BzrCommandError(
5347
"Tags can only be placed on a single revision, "
5348
"not on a range")
5349
revision_id = revision[0].as_revision_id(branch)
5258
branch.lock_write()
5259
try:
5260
if delete:
5261
branch.tags.delete_tag(tag_name)
5262
self.outf.write('Deleted tag %s.\n' % tag_name)
5350
5263
else:
5351
revision_id = branch.last_revision()
5352
if tag_name is None:
5353
tag_name = branch.automatic_tag_name(revision_id)
5354
if tag_name is None:
5355
raise errors.BzrCommandError(
5356
"Please specify a tag name.")
5357
if (not force) and branch.tags.has_tag(tag_name):
5358
raise errors.TagAlreadyExists(tag_name)
5359
branch.tags.set_tag(tag_name, revision_id)
5360
self.outf.write('Created tag %s.\n' % tag_name)
5264
if revision:
5265
if len(revision) != 1:
5266
raise errors.BzrCommandError(
5267
"Tags can only be placed on a single revision, "
5268
"not on a range")
5269
revision_id = revision[0].as_revision_id(branch)
5270
else:
5271
revision_id = branch.last_revision()
5272
if (not force) and branch.tags.has_tag(tag_name):
5273
raise errors.TagAlreadyExists(tag_name)
5274
branch.tags.set_tag(tag_name, revision_id)
5275
self.outf.write('Created tag %s.\n' % tag_name)
5276
finally:
5277
branch.unlock()
5361
5278
5362
5279
5363
5280
class cmd_tags(Command):
5364
__doc__ = """List tags.
5281
"""List tags.
5365
5282
5366
5283
This command shows a table of tag names and the revisions they reference.
5367
5284
"""
5368
5285
5369
5286
_see_also = ['tag']
5370
5287
takes_options = [
5371
custom_help('directory',
5372
help='Branch whose tags should be displayed.'),
5288
Option('directory',
5289
help='Branch whose tags should be displayed.',
5290
short_name='d',
5291
type=unicode,
5292
),
5373
5293
RegistryOption.from_kwargs('sort',
5374
5294
'Sort tags by different criteria.', title='Sorting',
5375
5295
alpha='Sort tags lexicographically (default).',
5392
5312
if not tags:
5393
5313
return
5394
5314
5395
self.add_cleanup(branch.lock_read().unlock)
5396
if revision:
5397
graph = branch.repository.get_graph()
5398
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5399
revid1, revid2 = rev1.rev_id, rev2.rev_id
5400
# only show revisions between revid1 and revid2 (inclusive)
5401
tags = [(tag, revid) for tag, revid in tags if
5402
graph.is_between(revid, revid1, revid2)]
5403
if sort == 'alpha':
5404
tags.sort()
5405
elif sort == 'time':
5406
timestamps = {}
5407
for tag, revid in tags:
5408
try:
5409
revobj = branch.repository.get_revision(revid)
5410
except errors.NoSuchRevision:
5411
timestamp = sys.maxint # place them at the end
5412
else:
5413
timestamp = revobj.timestamp
5414
timestamps[revid] = timestamp
5415
tags.sort(key=lambda x: timestamps[x[1]])
5416
if not show_ids:
5417
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5418
for index, (tag, revid) in enumerate(tags):
5419
try:
5420
revno = branch.revision_id_to_dotted_revno(revid)
5421
if isinstance(revno, tuple):
5422
revno = '.'.join(map(str, revno))
5423
except errors.NoSuchRevision:
5424
# Bad tag data/merges can lead to tagged revisions
5425
# which are not in this branch. Fail gracefully ...
5426
revno = '?'
5427
tags[index] = (tag, revno)
5428
self.cleanup_now()
5315
branch.lock_read()
5316
try:
5317
if revision:
5318
graph = branch.repository.get_graph()
5319
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5320
revid1, revid2 = rev1.rev_id, rev2.rev_id
5321
# only show revisions between revid1 and revid2 (inclusive)
5322
tags = [(tag, revid) for tag, revid in tags if
5323
graph.is_between(revid, revid1, revid2)]
5324
if sort == 'alpha':
5325
tags.sort()
5326
elif sort == 'time':
5327
timestamps = {}
5328
for tag, revid in tags:
5329
try:
5330
revobj = branch.repository.get_revision(revid)
5331
except errors.NoSuchRevision:
5332
timestamp = sys.maxint # place them at the end
5333
else:
5334
timestamp = revobj.timestamp
5335
timestamps[revid] = timestamp
5336
tags.sort(key=lambda x: timestamps[x[1]])
5337
if not show_ids:
5338
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5339
for index, (tag, revid) in enumerate(tags):
5340
try:
5341
revno = branch.revision_id_to_dotted_revno(revid)
5342
if isinstance(revno, tuple):
5343
revno = '.'.join(map(str, revno))
5344
except errors.NoSuchRevision:
5345
# Bad tag data/merges can lead to tagged revisions
5346
# which are not in this branch. Fail gracefully ...
5347
revno = '?'
5348
tags[index] = (tag, revno)
5349
finally:
5350
branch.unlock()
5429
5351
for tag, revspec in tags:
5430
5352
self.outf.write('%-20s %s\n' % (tag, revspec))
5431
5353
5432
5354
5433
5355
class cmd_reconfigure(Command):
5434
__doc__ = """Reconfigure the type of a bzr directory.
5356
"""Reconfigure the type of a bzr directory.
5435
5357
5436
5358
A target configuration must be specified.
5437
5359
5522
5444
5523
5445
5524
5446
class cmd_switch(Command):
5525
__doc__ = """Set the branch of a checkout and update.
5447
"""Set the branch of a checkout and update.
5526
5448
5527
5449
For lightweight checkouts, this changes the branch being referenced.
5528
5450
For heavyweight checkouts, this checks that there are no local commits
5544
5466
that of the master.
5545
5467
"""
5546
5468
5547
takes_args = ['to_location?']
5548
takes_options = ['directory',
5549
Option('force',
5469
takes_args = ['to_location']
5470
takes_options = [Option('force',
5550
5471
help='Switch even if local commits will be lost.'),
5551
'revision',
5552
5472
Option('create-branch', short_name='b',
5553
5473
help='Create the target branch from this one before'
5554
5474
' switching to it.'),
5555
]
5475
]
5556
5476
5557
def run(self, to_location=None, force=False, create_branch=False,
5558
revision=None, directory=u'.'):
5477
def run(self, to_location, force=False, create_branch=False):
5559
5478
from bzrlib import switch
5560
tree_location = directory
5561
revision = _get_one_revision('switch', revision)
5479
tree_location = '.'
5562
5480
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5563
if to_location is None:
5564
if revision is None:
5565
raise errors.BzrCommandError('You must supply either a'
5566
' revision or a location')
5567
to_location = tree_location
5568
5481
try:
5569
5482
branch = control_dir.open_branch()
5570
5483
had_explicit_nick = branch.get_config().has_explicit_nickname()
5575
5488
if branch is None:
5576
5489
raise errors.BzrCommandError('cannot create branch without'
5577
5490
' source branch')
5578
to_location = directory_service.directories.dereference(
5579
to_location)
5580
5491
if '/' not in to_location and '\\' not in to_location:
5581
5492
# This path is meant to be relative to the existing branch
5582
5493
this_url = self._get_branch_location(control_dir)
5584
5495
to_branch = branch.bzrdir.sprout(to_location,
5585
5496
possible_transports=[branch.bzrdir.root_transport],
5586
5497
source_branch=branch).open_branch()
5498
# try:
5499
# from_branch = control_dir.open_branch()
5500
# except errors.NotBranchError:
5501
# raise BzrCommandError('Cannot create a branch from this'
5502
# ' location when we cannot open this branch')
5503
# from_branch.bzrdir.sprout(
5504
pass
5587
5505
else:
5588
5506
try:
5589
5507
to_branch = Branch.open(to_location)
5591
5509
this_url = self._get_branch_location(control_dir)
5592
5510
to_branch = Branch.open(
5593
5511
urlutils.join(this_url, '..', to_location))
5594
if revision is not None:
5595
revision = revision.as_revision_id(to_branch)
5596
switch.switch(control_dir, to_branch, force, revision_id=revision)
5512
switch.switch(control_dir, to_branch, force)
5597
5513
if had_explicit_nick:
5598
5514
branch = control_dir.open_branch() #get the new branch!
5599
5515
branch.nick = to_branch.nick
5619
5535
5620
5536
5621
5537
class cmd_view(Command):
5622
__doc__ = """Manage filtered views.
5538
"""Manage filtered views.
5623
5539
5624
5540
Views provide a mask over the tree so that users can focus on
5625
5541
a subset of a tree when doing their work. After creating a view,
5773
5689
5774
5690
5775
5691
class cmd_hooks(Command):
5776
__doc__ = """Show hooks."""
5692
"""Show hooks."""
5777
5693
5778
5694
hidden = True
5779
5695
5792
5708
self.outf.write(" <no hooks installed>\n")
5793
5709
5794
5710
5795
class cmd_remove_branch(Command):
5796
__doc__ = """Remove a branch.
5797
5798
This will remove the branch from the specified location but
5799
will keep any working tree or repository in place.
5800
5801
:Examples:
5802
5803
Remove the branch at repo/trunk::
5804
5805
bzr remove-branch repo/trunk
5806
5807
"""
5808
5809
takes_args = ["location?"]
5810
5811
aliases = ["rmbranch"]
5812
5813
def run(self, location=None):
5814
if location is None:
5815
location = "."
5816
branch = Branch.open_containing(location)[0]
5817
branch.bzrdir.destroy_branch()
5818
5819
5820
5711
class cmd_shelve(Command):
5821
__doc__ = """Temporarily set aside some changes from the current tree.
5712
"""Temporarily set aside some changes from the current tree.
5822
5713
5823
5714
Shelve allows you to temporarily put changes you've made "on the shelf",
5824
5715
ie. out of the way, until a later time when you can bring them back from
5845
5736
takes_args = ['file*']
5846
5737
5847
5738
takes_options = [
5848
'directory',
5849
5739
'revision',
5850
5740
Option('all', help='Shelve all changes.'),
5851
5741
'message',
5860
5750
_see_also = ['unshelve']
5861
5751
5862
5752
def run(self, revision=None, all=False, file_list=None, message=None,
5863
writer=None, list=False, destroy=False, directory=u'.'):
5753
writer=None, list=False, destroy=False):
5864
5754
if list:
5865
5755
return self.run_for_list()
5866
5756
from bzrlib.shelf_ui import Shelver
5868
5758
writer = bzrlib.option.diff_writer_registry.get()
5869
5759
try:
5870
5760
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5871
file_list, message, destroy=destroy, directory=directory)
5761
file_list, message, destroy=destroy)
5872
5762
try:
5873
5763
shelver.run()
5874
5764
finally:
5878
5768
5879
5769
def run_for_list(self):
5880
5770
tree = WorkingTree.open_containing('.')[0]
5881
self.add_cleanup(tree.lock_read().unlock)
5882
manager = tree.get_shelf_manager()
5883
shelves = manager.active_shelves()
5884
if len(shelves) == 0:
5885
note('No shelved changes.')
5886
return 0
5887
for shelf_id in reversed(shelves):
5888
message = manager.get_metadata(shelf_id).get('message')
5889
if message is None:
5890
message = '<no message>'
5891
self.outf.write('%3d: %s\n' % (shelf_id, message))
5892
return 1
5771
tree.lock_read()
5772
try:
5773
manager = tree.get_shelf_manager()
5774
shelves = manager.active_shelves()
5775
if len(shelves) == 0:
5776
note('No shelved changes.')
5777
return 0
5778
for shelf_id in reversed(shelves):
5779
message = manager.get_metadata(shelf_id).get('message')
5780
if message is None:
5781
message = '<no message>'
5782
self.outf.write('%3d: %s\n' % (shelf_id, message))
5783
return 1
5784
finally:
5785
tree.unlock()
5893
5786
5894
5787
5895
5788
class cmd_unshelve(Command):
5896
__doc__ = """Restore shelved changes.
5789
"""Restore shelved changes.
5897
5790
5898
5791
By default, the most recently shelved changes are restored. However if you
5899
5792
specify a shelf by id those changes will be restored instead. This works
5902
5795
5903
5796
takes_args = ['shelf_id?']
5904
5797
takes_options = [
5905
'directory',
5906
5798
RegistryOption.from_kwargs(
5907
5799
'action', help="The action to perform.",
5908
5800
enum_switch=False, value_switches=True,
5909
5801
apply="Apply changes and remove from the shelf.",
5910
5802
dry_run="Show changes, but do not apply or remove them.",
5911
preview="Instead of unshelving the changes, show the diff that "
5912
"would result from unshelving.",
5913
5803
delete_only="Delete changes without applying them.",
5914
5804
keep="Apply changes but don't delete them.",
5915
5805
)
5916
5806
]
5917
5807
_see_also = ['shelve']
5918
5808
5919
def run(self, shelf_id=None, action='apply', directory=u'.'):
5809
def run(self, shelf_id=None, action='apply'):
5920
5810
from bzrlib.shelf_ui import Unshelver
5921
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5811
unshelver = Unshelver.from_args(shelf_id, action)
5922
5812
try:
5923
5813
unshelver.run()
5924
5814
finally:
5926
5816
5927
5817
5928
5818
class cmd_clean_tree(Command):
5929
__doc__ = """Remove unwanted files from working tree.
5819
"""Remove unwanted files from working tree.
5930
5820
5931
5821
By default, only unknown files, not ignored files, are deleted. Versioned
5932
5822
files are never deleted.
5940
5830
5941
5831
To check what clean-tree will do, use --dry-run.
5942
5832
"""
5943
takes_options = ['directory',
5944
Option('ignored', help='Delete all ignored files.'),
5833
takes_options = [Option('ignored', help='Delete all ignored files.'),
5945
5834
Option('detritus', help='Delete conflict files, merge'
5946
5835
' backups, and failed selftest dirs.'),
5947
5836
Option('unknown',
5950
5839
' deleting them.'),
5951
5840
Option('force', help='Do not prompt before deleting.')]
5952
5841
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5953
force=False, directory=u'.'):
5842
force=False):
5954
5843
from bzrlib.clean_tree import clean_tree
5955
5844
if not (unknown or ignored or detritus):
5956
5845
unknown = True
5957
5846
if dry_run:
5958
5847
force = True
5959
clean_tree(directory, unknown=unknown, ignored=ignored,
5960
detritus=detritus, dry_run=dry_run, no_prompt=force)
5848
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5849
dry_run=dry_run, no_prompt=force)
5961
5850
5962
5851
5963
5852
class cmd_reference(Command):
5964
__doc__ = """list, view and set branch locations for nested trees.
5853
"""list, view and set branch locations for nested trees.
5965
5854
5966
5855
If no arguments are provided, lists the branch locations for nested trees.
5967
5856
If one argument is provided, display the branch location for that tree.
6007
5896
self.outf.write('%s %s\n' % (path, location))
6008
5897
6009
5898
6010
def _register_lazy_builtins():
6011
# register lazy builtins from other modules; called at startup and should
6012
# be only called once.
6013
for (name, aliases, module_name) in [
6014
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6015
('cmd_dpush', [], 'bzrlib.foreign'),
6016
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6017
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6018
('cmd_conflicts', [], 'bzrlib.conflicts'),
6019
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6020
]:
6021
builtin_command_registry.register_lazy(name, aliases, module_name)
5899
# these get imported and then picked up by the scan for cmd_*
5900
# TODO: Some more consistent way to split command definitions across files;
5901
# we do need to load at least some information about them to know of
5902
# aliases. ideally we would avoid loading the implementation until the
5903
# details were needed.
5904
from bzrlib.cmd_version_info import cmd_version_info
5905
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5906
from bzrlib.bundle.commands import (
5907
cmd_bundle_info,
5908
)
5909
from bzrlib.foreign import cmd_dpush
5910
from bzrlib.sign_my_commits import cmd_sign_my_commits
5911
from bzrlib.weave_commands import cmd_versionedfile_list, \
5912
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0