~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Martin Pool
  • Date: 2011-03-28 01:28:09 UTC
  • mto: (5425.4.19 220464-stale-locks)
  • mto: This revision was merged to the branch mainline in revision 5970.
  • Revision ID: mbp@canonical.com-20110328012809-frw003r09tcrxkiz
Represent lock held info as an object, not just a dict

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
250
250
    To skip the display of pending merge information altogether, use
251
251
    the no-pending option or specify a file/directory.
252
252
 
253
 
    To compare the working directory to a specific revision, pass a
254
 
    single revision to the revision argument.
255
 
 
256
 
    To see which files have changed in a specific revision, or between
257
 
    two revisions, pass a revision range to the revision argument.
258
 
    This will produce the same results as calling 'bzr diff --summarize'.
 
253
    If a revision argument is given, the status is calculated against
 
254
    that revision, or between two revisions if two are provided.
259
255
    """
260
256
 
261
257
    # TODO: --no-recurse, --recurse options
328
324
        if revision_id is None and revision is None:
329
325
            raise errors.BzrCommandError('You must supply either'
330
326
                                         ' --revision or a revision_id')
331
 
 
332
 
        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
 
327
        b = WorkingTree.open_containing(directory)[0].branch
333
328
 
334
329
        revisions = b.repository.revisions
335
330
        if revisions is None:
413
408
                self.outf.write(page_bytes[:header_end])
414
409
                page_bytes = data
415
410
            self.outf.write('\nPage %d\n' % (page_idx,))
416
 
            if len(page_bytes) == 0:
417
 
                self.outf.write('(empty)\n');
418
 
            else:
419
 
                decomp_bytes = zlib.decompress(page_bytes)
420
 
                self.outf.write(decomp_bytes)
421
 
                self.outf.write('\n')
 
411
            decomp_bytes = zlib.decompress(page_bytes)
 
412
            self.outf.write(decomp_bytes)
 
413
            self.outf.write('\n')
422
414
 
423
415
    def _dump_entries(self, trans, basename):
424
416
        try:
485
477
            d.destroy_workingtree()
486
478
 
487
479
 
488
 
class cmd_repair_workingtree(Command):
489
 
    __doc__ = """Reset the working tree state file.
490
 
 
491
 
    This is not meant to be used normally, but more as a way to recover from
492
 
    filesystem corruption, etc. This rebuilds the working inventory back to a
493
 
    'known good' state. Any new modifications (adding a file, renaming, etc)
494
 
    will be lost, though modified files will still be detected as such.
495
 
 
496
 
    Most users will want something more like "bzr revert" or "bzr update"
497
 
    unless the state file has become corrupted.
498
 
 
499
 
    By default this attempts to recover the current state by looking at the
500
 
    headers of the state file. If the state file is too corrupted to even do
501
 
    that, you can supply --revision to force the state of the tree.
502
 
    """
503
 
 
504
 
    takes_options = ['revision', 'directory',
505
 
        Option('force',
506
 
               help='Reset the tree even if it doesn\'t appear to be'
507
 
                    ' corrupted.'),
508
 
    ]
509
 
    hidden = True
510
 
 
511
 
    def run(self, revision=None, directory='.', force=False):
512
 
        tree, _ = WorkingTree.open_containing(directory)
513
 
        self.add_cleanup(tree.lock_tree_write().unlock)
514
 
        if not force:
515
 
            try:
516
 
                tree.check_state()
517
 
            except errors.BzrError:
518
 
                pass # There seems to be a real error here, so we'll reset
519
 
            else:
520
 
                # Refuse
521
 
                raise errors.BzrCommandError(
522
 
                    'The tree does not appear to be corrupt. You probably'
523
 
                    ' want "bzr revert" instead. Use "--force" if you are'
524
 
                    ' sure you want to reset the working tree.')
525
 
        if revision is None:
526
 
            revision_ids = None
527
 
        else:
528
 
            revision_ids = [r.as_revision_id(tree.branch) for r in revision]
529
 
        try:
530
 
            tree.reset_state(revision_ids)
531
 
        except errors.BzrError, e:
532
 
            if revision_ids is None:
533
 
                extra = (', the header appears corrupt, try passing -r -1'
534
 
                         ' to set the state to the last commit')
535
 
            else:
536
 
                extra = ''
537
 
            raise errors.BzrCommandError('failed to reset the tree state'
538
 
                                         + extra)
539
 
 
540
 
 
541
480
class cmd_revno(Command):
542
481
    __doc__ = """Show current revision number.
543
482
 
962
901
    match the remote one, use pull --overwrite. This will work even if the two
963
902
    branches have diverged.
964
903
 
965
 
    If there is no default location set, the first pull will set it (use
966
 
    --no-remember to avoid settting it). After that, you can omit the
967
 
    location to use the default.  To change the default, use --remember. The
968
 
    value will only be saved if the remote location can be accessed.
 
904
    If there is no default location set, the first pull will set it.  After
 
905
    that, you can omit the location to use the default.  To change the
 
906
    default, use --remember. The value will only be saved if the remote
 
907
    location can be accessed.
969
908
 
970
909
    Note: The location can be specified either in the form of a branch,
971
910
    or in the form of a path to a file containing a merge directive generated
984
923
                 "branch.  Local pulls are not applied to "
985
924
                 "the master branch."
986
925
            ),
987
 
        Option('show-base',
988
 
            help="Show base revision text in conflicts.")
989
926
        ]
990
927
    takes_args = ['location?']
991
928
    encoding_type = 'replace'
992
929
 
993
 
    def run(self, location=None, remember=None, overwrite=False,
 
930
    def run(self, location=None, remember=False, overwrite=False,
994
931
            revision=None, verbose=False,
995
 
            directory=None, local=False,
996
 
            show_base=False):
 
932
            directory=None, local=False):
997
933
        # FIXME: too much stuff is in the command class
998
934
        revision_id = None
999
935
        mergeable = None
1008
944
            branch_to = Branch.open_containing(directory)[0]
1009
945
            self.add_cleanup(branch_to.lock_write().unlock)
1010
946
 
1011
 
        if tree_to is None and show_base:
1012
 
            raise errors.BzrCommandError("Need working tree for --show-base.")
1013
 
 
1014
947
        if local and not branch_to.get_bound_location():
1015
948
            raise errors.LocalRequiresBoundBranch()
1016
949
 
1047
980
            branch_from = Branch.open(location,
1048
981
                possible_transports=possible_transports)
1049
982
            self.add_cleanup(branch_from.lock_read().unlock)
1050
 
            # Remembers if asked explicitly or no previous location is set
1051
 
            if (remember
1052
 
                or (remember is None and branch_to.get_parent() is None)):
 
983
 
 
984
            if branch_to.get_parent() is None or remember:
1053
985
                branch_to.set_parent(branch_from.base)
1054
986
 
1055
987
        if revision is not None:
1062
994
                view_info=view_info)
1063
995
            result = tree_to.pull(
1064
996
                branch_from, overwrite, revision_id, change_reporter,
1065
 
                possible_transports=possible_transports, local=local,
1066
 
                show_base=show_base)
 
997
                possible_transports=possible_transports, local=local)
1067
998
        else:
1068
999
            result = branch_to.pull(
1069
1000
                branch_from, overwrite, revision_id, local=local)
1073
1004
            log.show_branch_change(
1074
1005
                branch_to, self.outf, result.old_revno,
1075
1006
                result.old_revid)
1076
 
        if getattr(result, 'tag_conflicts', None):
1077
 
            return 1
1078
 
        else:
1079
 
            return 0
1080
1007
 
1081
1008
 
1082
1009
class cmd_push(Command):
1099
1026
    do a merge (see bzr help merge) from the other branch, and commit that.
1100
1027
    After that you will be able to do a push without '--overwrite'.
1101
1028
 
1102
 
    If there is no default push location set, the first push will set it (use
1103
 
    --no-remember to avoid settting it).  After that, you can omit the
1104
 
    location to use the default.  To change the default, use --remember. The
1105
 
    value will only be saved if the remote location can be accessed.
 
1029
    If there is no default push location set, the first push will set it.
 
1030
    After that, you can omit the location to use the default.  To change the
 
1031
    default, use --remember. The value will only be saved if the remote
 
1032
    location can be accessed.
1106
1033
    """
1107
1034
 
1108
1035
    _see_also = ['pull', 'update', 'working-trees']
1129
1056
        Option('strict',
1130
1057
               help='Refuse to push if there are uncommitted changes in'
1131
1058
               ' the working tree, --no-strict disables the check.'),
1132
 
        Option('no-tree',
1133
 
               help="Don't populate the working tree, even for protocols"
1134
 
               " that support it."),
1135
1059
        ]
1136
1060
    takes_args = ['location?']
1137
1061
    encoding_type = 'replace'
1138
1062
 
1139
 
    def run(self, location=None, remember=None, overwrite=False,
 
1063
    def run(self, location=None, remember=False, overwrite=False,
1140
1064
        create_prefix=False, verbose=False, revision=None,
1141
1065
        use_existing_dir=False, directory=None, stacked_on=None,
1142
 
        stacked=False, strict=None, no_tree=False):
 
1066
        stacked=False, strict=None):
1143
1067
        from bzrlib.push import _show_push_branch
1144
1068
 
1145
1069
        if directory is None:
1191
1115
        _show_push_branch(br_from, revision_id, location, self.outf,
1192
1116
            verbose=verbose, overwrite=overwrite, remember=remember,
1193
1117
            stacked_on=stacked_on, create_prefix=create_prefix,
1194
 
            use_existing_dir=use_existing_dir, no_tree=no_tree)
 
1118
            use_existing_dir=use_existing_dir)
1195
1119
 
1196
1120
 
1197
1121
class cmd_branch(Command):
1206
1130
 
1207
1131
    To retrieve the branch as of a particular revision, supply the --revision
1208
1132
    parameter, as in "branch foo/bar -r 5".
1209
 
 
1210
 
    The synonyms 'clone' and 'get' for this command are deprecated.
1211
1133
    """
1212
1134
 
1213
1135
    _see_also = ['checkout']
1243
1165
            files_from=None):
1244
1166
        from bzrlib import switch as _mod_switch
1245
1167
        from bzrlib.tag import _merge_tags_if_possible
1246
 
        if self.invoked_as in ['get', 'clone']:
1247
 
            ui.ui_factory.show_user_warning(
1248
 
                'deprecated_command',
1249
 
                deprecated_name=self.invoked_as,
1250
 
                recommended_name='branch',
1251
 
                deprecated_in_version='2.4')
1252
1168
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1253
1169
            from_location)
1254
1170
        if not (hardlink or files_from):
1438
1354
    If you want to discard your local changes, you can just do a
1439
1355
    'bzr revert' instead of 'bzr commit' after the update.
1440
1356
 
1441
 
    If you want to restore a file that has been removed locally, use
1442
 
    'bzr revert' instead of 'bzr update'.
1443
 
 
1444
1357
    If the tree's branch is bound to a master branch, it will also update
1445
1358
    the branch from the master.
1446
1359
    """
1447
1360
 
1448
1361
    _see_also = ['pull', 'working-trees', 'status-flags']
1449
1362
    takes_args = ['dir?']
1450
 
    takes_options = ['revision',
1451
 
                     Option('show-base',
1452
 
                            help="Show base revision text in conflicts."),
1453
 
                     ]
 
1363
    takes_options = ['revision']
1454
1364
    aliases = ['up']
1455
1365
 
1456
 
    def run(self, dir='.', revision=None, show_base=None):
 
1366
    def run(self, dir='.', revision=None):
1457
1367
        if revision is not None and len(revision) != 1:
1458
1368
            raise errors.BzrCommandError(
1459
1369
                        "bzr update --revision takes exactly one revision")
1499
1409
                change_reporter,
1500
1410
                possible_transports=possible_transports,
1501
1411
                revision=revision_id,
1502
 
                old_tip=old_tip,
1503
 
                show_base=show_base)
 
1412
                old_tip=old_tip)
1504
1413
        except errors.NoSuchRevision, e:
1505
1414
            raise errors.BzrCommandError(
1506
1415
                                  "branch has no revision %s\n"
1582
1491
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1583
1492
            safe='Backup changed files (default).',
1584
1493
            keep='Delete from bzr but leave the working copy.',
1585
 
            no_backup='Don\'t backup changed files.',
1586
1494
            force='Delete all the specified files, even if they can not be '
1587
 
                'recovered and even if they are non-empty directories. '
1588
 
                '(deprecated, use no-backup)')]
 
1495
                'recovered and even if they are non-empty directories.')]
1589
1496
    aliases = ['rm', 'del']
1590
1497
    encoding_type = 'replace'
1591
1498
 
1592
1499
    def run(self, file_list, verbose=False, new=False,
1593
1500
        file_deletion_strategy='safe'):
1594
 
        if file_deletion_strategy == 'force':
1595
 
            note("(The --force option is deprecated, rather use --no-backup "
1596
 
                "in future.)")
1597
 
            file_deletion_strategy = 'no-backup'
1598
 
 
1599
1501
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1600
1502
 
1601
1503
        if file_list is not None:
1622
1524
            file_deletion_strategy = 'keep'
1623
1525
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1624
1526
            keep_files=file_deletion_strategy=='keep',
1625
 
            force=(file_deletion_strategy=='no-backup'))
 
1527
            force=file_deletion_strategy=='force')
1626
1528
 
1627
1529
 
1628
1530
class cmd_file_id(Command):
1783
1685
                ),
1784
1686
         Option('append-revisions-only',
1785
1687
                help='Never change revnos or the existing log.'
1786
 
                '  Append revisions to it only.'),
1787
 
         Option('no-tree',
1788
 
                'Create a branch without a working tree.')
 
1688
                '  Append revisions to it only.')
1789
1689
         ]
1790
1690
    def run(self, location=None, format=None, append_revisions_only=False,
1791
 
            create_prefix=False, no_tree=False):
 
1691
            create_prefix=False):
1792
1692
        if format is None:
1793
1693
            format = bzrdir.format_registry.make_bzrdir('default')
1794
1694
        if location is None:
1817
1717
        except errors.NotBranchError:
1818
1718
            # really a NotBzrDir error...
1819
1719
            create_branch = bzrdir.BzrDir.create_branch_convenience
1820
 
            if no_tree:
1821
 
                force_new_tree = False
1822
 
            else:
1823
 
                force_new_tree = None
1824
1720
            branch = create_branch(to_transport.base, format=format,
1825
 
                                   possible_transports=[to_transport],
1826
 
                                   force_new_tree=force_new_tree)
 
1721
                                   possible_transports=[to_transport])
1827
1722
            a_bzrdir = branch.bzrdir
1828
1723
        else:
1829
1724
            from bzrlib.transport.local import LocalTransport
1833
1728
                        raise errors.BranchExistsWithoutWorkingTree(location)
1834
1729
                raise errors.AlreadyBranchError(location)
1835
1730
            branch = a_bzrdir.create_branch()
1836
 
            if not no_tree:
1837
 
                a_bzrdir.create_workingtree()
 
1731
            a_bzrdir.create_workingtree()
1838
1732
        if append_revisions_only:
1839
1733
            try:
1840
1734
                branch.set_append_revisions_only(True)
1934
1828
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1935
1829
    produces patches suitable for "patch -p1".
1936
1830
 
1937
 
    Note that when using the -r argument with a range of revisions, the
1938
 
    differences are computed between the two specified revisions.  That
1939
 
    is, the command does not show the changes introduced by the first 
1940
 
    revision in the range.  This differs from the interpretation of 
1941
 
    revision ranges used by "bzr log" which includes the first revision
1942
 
    in the range.
1943
 
 
1944
1831
    :Exit values:
1945
1832
        1 - changed
1946
1833
        2 - unrepresentable changes
1964
1851
 
1965
1852
            bzr diff -r1..3 xxx
1966
1853
 
1967
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
1968
 
 
1969
 
            bzr diff -c2
1970
 
 
1971
 
        To see the changes introduced by revision X::
 
1854
        To see the changes introduced in revision X::
1972
1855
        
1973
1856
            bzr diff -cX
1974
1857
 
1978
1861
 
1979
1862
            bzr diff -r<chosen_parent>..X
1980
1863
 
1981
 
        The changes between the current revision and the previous revision
1982
 
        (equivalent to -c-1 and -r-2..-1)
 
1864
        The changes introduced by revision 2 (equivalent to -r1..2)::
1983
1865
 
1984
 
            bzr diff -r-2..
 
1866
            bzr diff -c2
1985
1867
 
1986
1868
        Show just the differences for file NEWS::
1987
1869
 
2031
1913
            type=unicode,
2032
1914
            ),
2033
1915
        RegistryOption('format',
2034
 
            short_name='F',
2035
1916
            help='Diff format to use.',
2036
1917
            lazy_registry=('bzrlib.diff', 'format_registry'),
2037
 
            title='Diff format'),
 
1918
            value_switches=False, title='Diff format'),
2038
1919
        ]
2039
1920
    aliases = ['di', 'dif']
2040
1921
    encoding_type = 'exact'
2121
2002
    @display_command
2122
2003
    def run(self, null=False, directory=u'.'):
2123
2004
        tree = WorkingTree.open_containing(directory)[0]
2124
 
        self.add_cleanup(tree.lock_read().unlock)
2125
2005
        td = tree.changes_from(tree.basis_tree())
2126
 
        self.cleanup_now()
2127
2006
        for path, id, kind, text_modified, meta_modified in td.modified:
2128
2007
            if null:
2129
2008
                self.outf.write(path + '\0')
2759
2638
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2760
2639
    precedence over the '!' exception patterns.
2761
2640
 
2762
 
    :Notes: 
2763
 
        
2764
 
    * Ignore patterns containing shell wildcards must be quoted from
2765
 
      the shell on Unix.
2766
 
 
2767
 
    * Ignore patterns starting with "#" act as comments in the ignore file.
2768
 
      To ignore patterns that begin with that character, use the "RE:" prefix.
 
2641
    Note: ignore patterns containing shell wildcards must be quoted from
 
2642
    the shell on Unix.
2769
2643
 
2770
2644
    :Examples:
2771
2645
        Ignore the top level Makefile::
2780
2654
 
2781
2655
            bzr ignore "!special.class"
2782
2656
 
2783
 
        Ignore files whose name begins with the "#" character::
2784
 
 
2785
 
            bzr ignore "RE:^#"
2786
 
 
2787
2657
        Ignore .o files under the lib directory::
2788
2658
 
2789
2659
            bzr ignore "lib/**/*.o"
2797
2667
            bzr ignore "RE:(?!debian/).*"
2798
2668
        
2799
2669
        Ignore everything except the "local" toplevel directory,
2800
 
        but always ignore autosave files ending in ~, even under local/::
 
2670
        but always ignore "*~" autosave files, even under local/::
2801
2671
        
2802
2672
            bzr ignore "*"
2803
2673
            bzr ignore "!./local"
2931
2801
         zip                          .zip
2932
2802
      =================       =========================
2933
2803
    """
2934
 
    encoding = 'exact'
2935
2804
    takes_args = ['dest', 'branch_or_subdir?']
2936
2805
    takes_options = ['directory',
2937
2806
        Option('format',
3115
2984
      to trigger updates to external systems like bug trackers. The --fixes
3116
2985
      option can be used to record the association between a revision and
3117
2986
      one or more bugs. See ``bzr help bugs`` for details.
 
2987
 
 
2988
      A selective commit may fail in some cases where the committed
 
2989
      tree would be invalid. Consider::
 
2990
  
 
2991
        bzr init foo
 
2992
        mkdir foo/bar
 
2993
        bzr add foo/bar
 
2994
        bzr commit foo -m "committing foo"
 
2995
        bzr mv foo/bar foo/baz
 
2996
        mkdir foo/bar
 
2997
        bzr add foo/bar
 
2998
        bzr commit foo/bar -m "committing bar but not baz"
 
2999
  
 
3000
      In the example above, the last commit will fail by design. This gives
 
3001
      the user the opportunity to decide whether they want to commit the
 
3002
      rename at the same time, separately first, or not at all. (As a general
 
3003
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3118
3004
    """
 
3005
    # TODO: Run hooks on tree to-be-committed, and after commit.
 
3006
 
 
3007
    # TODO: Strict commit that fails if there are deleted files.
 
3008
    #       (what does "deleted files" mean ??)
 
3009
 
 
3010
    # TODO: Give better message for -s, --summary, used by tla people
 
3011
 
 
3012
    # XXX: verbose currently does nothing
3119
3013
 
3120
3014
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3121
3015
    takes_args = ['selected*']
3153
3047
             Option('show-diff', short_name='p',
3154
3048
                    help='When no message is supplied, show the diff along'
3155
3049
                    ' with the status summary in the message editor.'),
3156
 
             Option('lossy', 
3157
 
                    help='When committing to a foreign version control '
3158
 
                    'system do not push data that can not be natively '
3159
 
                    'represented.'),
3160
3050
             ]
3161
3051
    aliases = ['ci', 'checkin']
3162
3052
 
3181
3071
 
3182
3072
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3183
3073
            unchanged=False, strict=False, local=False, fixes=None,
3184
 
            author=None, show_diff=False, exclude=None, commit_time=None,
3185
 
            lossy=False):
 
3074
            author=None, show_diff=False, exclude=None, commit_time=None):
3186
3075
        from bzrlib.errors import (
3187
3076
            PointlessCommit,
3188
3077
            ConflictsInTree,
3202
3091
                raise errors.BzrCommandError(
3203
3092
                    "Could not parse --commit-time: " + str(e))
3204
3093
 
 
3094
        # TODO: Need a blackbox test for invoking the external editor; may be
 
3095
        # slightly problematic to run this cross-platform.
 
3096
 
 
3097
        # TODO: do more checks that the commit will succeed before
 
3098
        # spending the user's valuable time typing a commit message.
 
3099
 
3205
3100
        properties = {}
3206
3101
 
3207
3102
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3284
3179
                        reporter=None, verbose=verbose, revprops=properties,
3285
3180
                        authors=author, timestamp=commit_stamp,
3286
3181
                        timezone=offset,
3287
 
                        exclude=tree.safe_relpath_files(exclude),
3288
 
                        lossy=lossy)
 
3182
                        exclude=tree.safe_relpath_files(exclude))
3289
3183
        except PointlessCommit:
3290
3184
            raise errors.BzrCommandError("No changes to commit."
3291
 
                " Please 'bzr add' the files you want to commit, or use"
3292
 
                " --unchanged to force an empty commit.")
 
3185
                              " Use --unchanged to commit anyhow.")
3293
3186
        except ConflictsInTree:
3294
3187
            raise errors.BzrCommandError('Conflicts detected in working '
3295
3188
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3376
3269
 
3377
3270
 
3378
3271
class cmd_upgrade(Command):
3379
 
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
3380
 
 
3381
 
    When the default format has changed after a major new release of
3382
 
    Bazaar, you may be informed during certain operations that you
3383
 
    should upgrade. Upgrading to a newer format may improve performance
3384
 
    or make new features available. It may however limit interoperability
3385
 
    with older repositories or with older versions of Bazaar.
3386
 
 
3387
 
    If you wish to upgrade to a particular format rather than the
3388
 
    current default, that can be specified using the --format option.
3389
 
    As a consequence, you can use the upgrade command this way to
3390
 
    "downgrade" to an earlier format, though some conversions are
3391
 
    a one way process (e.g. changing from the 1.x default to the
3392
 
    2.x default) so downgrading is not always possible.
3393
 
 
3394
 
    A backup.bzr.~#~ directory is created at the start of the conversion
3395
 
    process (where # is a number). By default, this is left there on
3396
 
    completion. If the conversion fails, delete the new .bzr directory
3397
 
    and rename this one back in its place. Use the --clean option to ask
3398
 
    for the backup.bzr directory to be removed on successful conversion.
3399
 
    Alternatively, you can delete it by hand if everything looks good
3400
 
    afterwards.
3401
 
 
3402
 
    If the location given is a shared repository, dependent branches
3403
 
    are also converted provided the repository converts successfully.
3404
 
    If the conversion of a branch fails, remaining branches are still
3405
 
    tried.
3406
 
 
3407
 
    For more information on upgrades, see the Bazaar Upgrade Guide,
3408
 
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
 
3272
    __doc__ = """Upgrade branch storage to current format.
 
3273
 
 
3274
    The check command or bzr developers may sometimes advise you to run
 
3275
    this command. When the default format has changed you may also be warned
 
3276
    during other operations to upgrade.
3409
3277
    """
3410
3278
 
3411
 
    _see_also = ['check', 'reconcile', 'formats']
 
3279
    _see_also = ['check']
3412
3280
    takes_args = ['url?']
3413
3281
    takes_options = [
3414
 
        RegistryOption('format',
3415
 
            help='Upgrade to a specific format.  See "bzr help'
3416
 
                 ' formats" for details.',
3417
 
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3418
 
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3419
 
            value_switches=True, title='Branch format'),
3420
 
        Option('clean',
3421
 
            help='Remove the backup.bzr directory if successful.'),
3422
 
        Option('dry-run',
3423
 
            help="Show what would be done, but don't actually do anything."),
3424
 
    ]
 
3282
                    RegistryOption('format',
 
3283
                        help='Upgrade to a specific format.  See "bzr help'
 
3284
                             ' formats" for details.',
 
3285
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
 
3286
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
3287
                        value_switches=True, title='Branch format'),
 
3288
                    ]
3425
3289
 
3426
 
    def run(self, url='.', format=None, clean=False, dry_run=False):
 
3290
    def run(self, url='.', format=None):
3427
3291
        from bzrlib.upgrade import upgrade
3428
 
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3429
 
        if exceptions:
3430
 
            if len(exceptions) == 1:
3431
 
                # Compatibility with historical behavior
3432
 
                raise exceptions[0]
3433
 
            else:
3434
 
                return 3
 
3292
        upgrade(url, format)
3435
3293
 
3436
3294
 
3437
3295
class cmd_whoami(Command):
3473
3331
                self.outf.write(c.username() + '\n')
3474
3332
            return
3475
3333
 
3476
 
        if email:
3477
 
            raise errors.BzrCommandError("--email can only be used to display existing "
3478
 
                                         "identity")
3479
 
 
3480
3334
        # display a warning if an email address isn't included in the given name.
3481
3335
        try:
3482
3336
            _mod_config.extract_email_address(name)
3836
3690
    with bzr send. If neither is specified, the default is the upstream branch
3837
3691
    or the branch most recently merged using --remember.
3838
3692
 
3839
 
    When merging from a branch, by default bzr will try to merge in all new
3840
 
    work from the other branch, automatically determining an appropriate base
3841
 
    revision.  If this fails, you may need to give an explicit base.
3842
 
 
3843
 
    To pick a different ending revision, pass "--revision OTHER".  bzr will
3844
 
    try to merge in all new work up to and including revision OTHER.
3845
 
 
3846
 
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
3847
 
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
3848
 
    causes some revisions to be skipped, i.e. if the destination branch does
3849
 
    not already contain revision BASE, such a merge is commonly referred to as
3850
 
    a "cherrypick". Unlike a normal merge, Bazaar does not currently track
3851
 
    cherrypicks. The changes look like a normal commit, and the history of the
3852
 
    changes from the other branch is not stored in the commit.
3853
 
 
3854
 
    Revision numbers are always relative to the source branch.
 
3693
    When merging a branch, by default the tip will be merged. To pick a different
 
3694
    revision, pass --revision. If you specify two values, the first will be used as
 
3695
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
 
3696
    available revisions, like this is commonly referred to as "cherrypicking".
 
3697
 
 
3698
    Revision numbers are always relative to the branch being merged.
 
3699
 
 
3700
    By default, bzr will try to merge in all new work from the other
 
3701
    branch, automatically determining an appropriate base.  If this
 
3702
    fails, you may need to give an explicit base.
3855
3703
 
3856
3704
    Merge will do its best to combine the changes in two branches, but there
3857
3705
    are some kinds of problems only a human can fix.  When it encounters those,
3860
3708
 
3861
3709
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
3862
3710
 
3863
 
    If there is no default branch set, the first merge will set it (use
3864
 
    --no-remember to avoid settting it). After that, you can omit the branch
3865
 
    to use the default.  To change the default, use --remember. The value will
3866
 
    only be saved if the remote location can be accessed.
 
3711
    If there is no default branch set, the first merge will set it. After
 
3712
    that, you can omit the branch to use the default.  To change the
 
3713
    default, use --remember. The value will only be saved if the remote
 
3714
    location can be accessed.
3867
3715
 
3868
3716
    The results of the merge are placed into the destination working
3869
3717
    directory, where they can be reviewed (with bzr diff), tested, and then
3881
3729
    you to apply each diff hunk and file change, similar to "shelve".
3882
3730
 
3883
3731
    :Examples:
3884
 
        To merge all new revisions from bzr.dev::
 
3732
        To merge the latest revision from bzr.dev::
3885
3733
 
3886
3734
            bzr merge ../bzr.dev
3887
3735
 
3934
3782
    ]
3935
3783
 
3936
3784
    def run(self, location=None, revision=None, force=False,
3937
 
            merge_type=None, show_base=False, reprocess=None, remember=None,
 
3785
            merge_type=None, show_base=False, reprocess=None, remember=False,
3938
3786
            uncommitted=False, pull=False,
3939
3787
            directory=None,
3940
3788
            preview=False,
3948
3796
        merger = None
3949
3797
        allow_pending = True
3950
3798
        verified = 'inapplicable'
3951
 
 
3952
3799
        tree = WorkingTree.open_containing(directory)[0]
3953
 
        if tree.branch.revno() == 0:
3954
 
            raise errors.BzrCommandError('Merging into empty branches not currently supported, '
3955
 
                                         'https://bugs.launchpad.net/bzr/+bug/308562')
3956
3800
 
3957
3801
        try:
3958
3802
            basis_tree = tree.revision_tree(tree.last_revision())
4006
3850
            merger.other_rev_id is not None):
4007
3851
            note('Nothing to do.')
4008
3852
            return 0
4009
 
        if pull and not preview:
 
3853
        if pull:
4010
3854
            if merger.interesting_files is not None:
4011
3855
                raise errors.BzrCommandError('Cannot pull individual files')
4012
3856
            if (merger.base_rev_id == tree.last_revision()):
4121
3965
        if other_revision_id is None:
4122
3966
            other_revision_id = _mod_revision.ensure_null(
4123
3967
                other_branch.last_revision())
4124
 
        # Remember where we merge from. We need to remember if:
4125
 
        # - user specify a location (and we don't merge from the parent
4126
 
        #   branch)
4127
 
        # - user ask to remember or there is no previous location set to merge
4128
 
        #   from and user didn't ask to *not* remember
4129
 
        if (user_location is not None
4130
 
            and ((remember
4131
 
                  or (remember is None
4132
 
                      and tree.branch.get_submit_branch() is None)))):
 
3968
        # Remember where we merge from
 
3969
        if ((remember or tree.branch.get_submit_branch() is None) and
 
3970
             user_location is not None):
4133
3971
            tree.branch.set_submit_branch(other_branch.base)
4134
 
        # Merge tags (but don't set them in the master branch yet, the user
4135
 
        # might revert this merge).  Commit will propagate them.
4136
 
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
 
3972
        _merge_tags_if_possible(other_branch, tree.branch)
4137
3973
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4138
3974
            other_revision_id, base_revision_id, other_branch, base_branch)
4139
3975
        if other_path != '':
4307
4143
    last committed revision is used.
4308
4144
 
4309
4145
    To remove only some changes, without reverting to a prior version, use
4310
 
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
4311
 
    will remove the changes introduced by the second last commit (-2), without
4312
 
    affecting the changes introduced by the last commit (-1).  To remove
4313
 
    certain changes on a hunk-by-hunk basis, see the shelve command.
 
4146
    merge instead.  For example, "merge . --revision -2..-3" will remove the
 
4147
    changes introduced by -2, without affecting the changes introduced by -1.
 
4148
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4314
4149
 
4315
4150
    By default, any files that have been manually changed will be backed up
4316
4151
    first.  (Files changed only by merge are not backed up.)  Backup files have
4346
4181
    target branches.
4347
4182
    """
4348
4183
 
4349
 
    _see_also = ['cat', 'export', 'merge', 'shelve']
 
4184
    _see_also = ['cat', 'export']
4350
4185
    takes_options = [
4351
4186
        'revision',
4352
4187
        Option('no-backup', "Do not save backups of reverted files."),
4645
4480
 
4646
4481
    @display_command
4647
4482
    def run(self, verbose=False):
4648
 
        from bzrlib import plugin
4649
 
        # Don't give writelines a generator as some codecs don't like that
4650
 
        self.outf.writelines(
4651
 
            list(plugin.describe_plugins(show_paths=verbose)))
 
4483
        import bzrlib.plugin
 
4484
        from inspect import getdoc
 
4485
        result = []
 
4486
        for name, plugin in bzrlib.plugin.plugins().items():
 
4487
            version = plugin.__version__
 
4488
            if version == 'unknown':
 
4489
                version = ''
 
4490
            name_ver = '%s %s' % (name, version)
 
4491
            d = getdoc(plugin.module)
 
4492
            if d:
 
4493
                doc = d.split('\n')[0]
 
4494
            else:
 
4495
                doc = '(no description)'
 
4496
            result.append((name_ver, doc, plugin.path()))
 
4497
        for name_ver, doc, path in sorted(result):
 
4498
            self.outf.write("%s\n" % name_ver)
 
4499
            self.outf.write("   %s\n" % doc)
 
4500
            if verbose:
 
4501
                self.outf.write("   %s\n" % path)
 
4502
            self.outf.write("\n")
4652
4503
 
4653
4504
 
4654
4505
class cmd_testament(Command):
4707
4558
    @display_command
4708
4559
    def run(self, filename, all=False, long=False, revision=None,
4709
4560
            show_ids=False, directory=None):
4710
 
        from bzrlib.annotate import (
4711
 
            annotate_file_tree,
4712
 
            )
 
4561
        from bzrlib.annotate import annotate_file, annotate_file_tree
4713
4562
        wt, branch, relpath = \
4714
4563
            _open_directory_or_containing_tree_or_branch(filename, directory)
4715
4564
        if wt is not None:
4718
4567
            self.add_cleanup(branch.lock_read().unlock)
4719
4568
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4720
4569
        self.add_cleanup(tree.lock_read().unlock)
4721
 
        if wt is not None and revision is None:
 
4570
        if wt is not None:
4722
4571
            file_id = wt.path2id(relpath)
4723
4572
        else:
4724
4573
            file_id = tree.path2id(relpath)
4725
4574
        if file_id is None:
4726
4575
            raise errors.NotVersionedError(filename)
 
4576
        file_version = tree.inventory[file_id].revision
4727
4577
        if wt is not None and revision is None:
4728
4578
            # If there is a tree and we're not annotating historical
4729
4579
            # versions, annotate the working tree's content.
4730
4580
            annotate_file_tree(wt, file_id, self.outf, long, all,
4731
4581
                show_ids=show_ids)
4732
4582
        else:
4733
 
            annotate_file_tree(tree, file_id, self.outf, long, all,
4734
 
                show_ids=show_ids, branch=branch)
 
4583
            annotate_file(branch, file_version, file_id, long, all, self.outf,
 
4584
                          show_ids=show_ids)
4735
4585
 
4736
4586
 
4737
4587
class cmd_re_sign(Command):
4951
4801
            self.outf.write('The above revision(s) will be removed.\n')
4952
4802
 
4953
4803
        if not force:
4954
 
            if not ui.ui_factory.confirm_action(
4955
 
                    'Uncommit these revisions',
4956
 
                    'bzrlib.builtins.uncommit',
4957
 
                    {}):
4958
 
                self.outf.write('Canceled\n')
 
4804
            if not ui.ui_factory.get_boolean('Are you sure'):
 
4805
                self.outf.write('Canceled')
4959
4806
                return 0
4960
4807
 
4961
4808
        mutter('Uncommitting from {%s} to {%s}',
4988
4835
    takes_options = [
4989
4836
        Option('config',
4990
4837
               help='LOCATION is the directory where the config lock is.'),
4991
 
        Option('force',
4992
 
            help='Do not ask for confirmation before breaking the lock.'),
4993
4838
        ]
4994
4839
 
4995
 
    def run(self, location=None, config=False, force=False):
 
4840
    def run(self, location=None, config=False):
4996
4841
        if location is None:
4997
4842
            location = u'.'
4998
 
        if force:
4999
 
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
5000
 
                None,
5001
 
                {'bzrlib.lockdir.break': True})
5002
4843
        if config:
5003
4844
            conf = _mod_config.LockableConfig(file_name=location)
5004
4845
            conf.break_lock()
5098
4939
    not part of it.  (Such trees can be produced by "bzr split", but also by
5099
4940
    running "bzr branch" with the target inside a tree.)
5100
4941
 
5101
 
    The result is a combined tree, with the subtree no longer an independent
 
4942
    The result is a combined tree, with the subtree no longer an independant
5102
4943
    part.  This is marked as a merge of the subtree into the containing tree,
5103
4944
    and all history is preserved.
5104
4945
    """
5294
5135
    source branch defaults to that containing the working directory, but can
5295
5136
    be changed using --from.
5296
5137
 
5297
 
    Both the submit branch and the public branch follow the usual behavior with
5298
 
    respect to --remember: If there is no default location set, the first send
5299
 
    will set it (use --no-remember to avoid settting it). After that, you can
5300
 
    omit the location to use the default.  To change the default, use
5301
 
    --remember. The value will only be saved if the location can be accessed.
5302
 
 
5303
5138
    In order to calculate those changes, bzr must analyse the submit branch.
5304
5139
    Therefore it is most efficient for the submit branch to be a local mirror.
5305
5140
    If a public location is known for the submit_branch, that location is used
5374
5209
        ]
5375
5210
 
5376
5211
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5377
 
            no_patch=False, revision=None, remember=None, output=None,
 
5212
            no_patch=False, revision=None, remember=False, output=None,
5378
5213
            format=None, mail_to=None, message=None, body=None,
5379
5214
            strict=None, **kwargs):
5380
5215
        from bzrlib.send import send
5506
5341
            if tag_name is None:
5507
5342
                raise errors.BzrCommandError("No tag specified to delete.")
5508
5343
            branch.tags.delete_tag(tag_name)
5509
 
            note('Deleted tag %s.' % tag_name)
 
5344
            self.outf.write('Deleted tag %s.\n' % tag_name)
5510
5345
        else:
5511
5346
            if revision:
5512
5347
                if len(revision) != 1:
5524
5359
            if (not force) and branch.tags.has_tag(tag_name):
5525
5360
                raise errors.TagAlreadyExists(tag_name)
5526
5361
            branch.tags.set_tag(tag_name, revision_id)
5527
 
            note('Created tag %s.' % tag_name)
 
5362
            self.outf.write('Created tag %s.\n' % tag_name)
5528
5363
 
5529
5364
 
5530
5365
class cmd_tags(Command):
5537
5372
    takes_options = [
5538
5373
        custom_help('directory',
5539
5374
            help='Branch whose tags should be displayed.'),
5540
 
        RegistryOption('sort',
 
5375
        RegistryOption.from_kwargs('sort',
5541
5376
            'Sort tags by different criteria.', title='Sorting',
5542
 
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
 
5377
            alpha='Sort tags lexicographically (default).',
 
5378
            time='Sort tags chronologically.',
5543
5379
            ),
5544
5380
        'show-ids',
5545
5381
        'revision',
5546
5382
    ]
5547
5383
 
5548
5384
    @display_command
5549
 
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
5550
 
        from bzrlib.tag import tag_sort_methods
 
5385
    def run(self,
 
5386
            directory='.',
 
5387
            sort='alpha',
 
5388
            show_ids=False,
 
5389
            revision=None,
 
5390
            ):
5551
5391
        branch, relpath = Branch.open_containing(directory)
5552
5392
 
5553
5393
        tags = branch.tags.get_tag_dict().items()
5562
5402
            # only show revisions between revid1 and revid2 (inclusive)
5563
5403
            tags = [(tag, revid) for tag, revid in tags if
5564
5404
                graph.is_between(revid, revid1, revid2)]
5565
 
        if sort is None:
5566
 
            sort = tag_sort_methods.get()
5567
 
        sort(branch, tags)
 
5405
        if sort == 'alpha':
 
5406
            tags.sort()
 
5407
        elif sort == 'time':
 
5408
            timestamps = {}
 
5409
            for tag, revid in tags:
 
5410
                try:
 
5411
                    revobj = branch.repository.get_revision(revid)
 
5412
                except errors.NoSuchRevision:
 
5413
                    timestamp = sys.maxint # place them at the end
 
5414
                else:
 
5415
                    timestamp = revobj.timestamp
 
5416
                timestamps[revid] = timestamp
 
5417
            tags.sort(key=lambda x: timestamps[x[1]])
5568
5418
        if not show_ids:
5569
5419
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5570
5420
            for index, (tag, revid) in enumerate(tags):
5572
5422
                    revno = branch.revision_id_to_dotted_revno(revid)
5573
5423
                    if isinstance(revno, tuple):
5574
5424
                        revno = '.'.join(map(str, revno))
5575
 
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
 
5425
                except errors.NoSuchRevision:
5576
5426
                    # Bad tag data/merges can lead to tagged revisions
5577
5427
                    # which are not in this branch. Fail gracefully ...
5578
5428
                    revno = '?'
5968
5818
            location = "."
5969
5819
        branch = Branch.open_containing(location)[0]
5970
5820
        branch.bzrdir.destroy_branch()
5971
 
 
 
5821
        
5972
5822
 
5973
5823
class cmd_shelve(Command):
5974
5824
    __doc__ = """Temporarily set aside some changes from the current tree.
5993
5843
 
5994
5844
    You can put multiple items on the shelf, and by default, 'unshelve' will
5995
5845
    restore the most recently shelved changes.
5996
 
 
5997
 
    For complicated changes, it is possible to edit the changes in a separate
5998
 
    editor program to decide what the file remaining in the working copy
5999
 
    should look like.  To do this, add the configuration option
6000
 
 
6001
 
        change_editor = PROGRAM @new_path @old_path
6002
 
 
6003
 
    where @new_path is replaced with the path of the new version of the 
6004
 
    file and @old_path is replaced with the path of the old version of 
6005
 
    the file.  The PROGRAM should save the new file with the desired 
6006
 
    contents of the file in the working tree.
6007
 
        
6008
5846
    """
6009
5847
 
6010
5848
    takes_args = ['file*']
6022
5860
        Option('destroy',
6023
5861
               help='Destroy removed changes instead of shelving them.'),
6024
5862
    ]
6025
 
    _see_also = ['unshelve', 'configuration']
 
5863
    _see_also = ['unshelve']
6026
5864
 
6027
5865
    def run(self, revision=None, all=False, file_list=None, message=None,
6028
 
            writer=None, list=False, destroy=False, directory=None):
 
5866
            writer=None, list=False, destroy=False, directory=u'.'):
6029
5867
        if list:
6030
 
            return self.run_for_list(directory=directory)
 
5868
            return self.run_for_list()
6031
5869
        from bzrlib.shelf_ui import Shelver
6032
5870
        if writer is None:
6033
5871
            writer = bzrlib.option.diff_writer_registry.get()
6041
5879
        except errors.UserAbort:
6042
5880
            return 0
6043
5881
 
6044
 
    def run_for_list(self, directory=None):
6045
 
        if directory is None:
6046
 
            directory = u'.'
6047
 
        tree = WorkingTree.open_containing(directory)[0]
 
5882
    def run_for_list(self):
 
5883
        tree = WorkingTree.open_containing('.')[0]
6048
5884
        self.add_cleanup(tree.lock_read().unlock)
6049
5885
        manager = tree.get_shelf_manager()
6050
5886
        shelves = manager.active_shelves()
6109
5945
    """
6110
5946
    takes_options = ['directory',
6111
5947
                     Option('ignored', help='Delete all ignored files.'),
6112
 
                     Option('detritus', help='Delete conflict files, merge and revert'
 
5948
                     Option('detritus', help='Delete conflict files, merge'
6113
5949
                            ' backups, and failed selftest dirs.'),
6114
5950
                     Option('unknown',
6115
5951
                            help='Delete files unknown to bzr (default).'),
6174
6010
            self.outf.write('%s %s\n' % (path, location))
6175
6011
 
6176
6012
 
6177
 
class cmd_export_pot(Command):
6178
 
    __doc__ = """Export command helps and error messages in po format."""
6179
 
 
6180
 
    hidden = True
6181
 
 
6182
 
    def run(self):
6183
 
        from bzrlib.export_pot import export_pot
6184
 
        export_pot(self.outf)
6185
 
 
6186
 
 
6187
6013
def _register_lazy_builtins():
6188
6014
    # register lazy builtins from other modules; called at startup and should
6189
6015
    # be only called once.
6190
6016
    for (name, aliases, module_name) in [
6191
6017
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6192
 
        ('cmd_config', [], 'bzrlib.config'),
6193
6018
        ('cmd_dpush', [], 'bzrlib.foreign'),
6194
6019
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6195
6020
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6196
6021
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6197
6022
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6198
 
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6199
6023
        ]:
6200
6024
        builtin_command_registry.register_lazy(name, aliases, module_name)