~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Jelmer Vernooij
  • Date: 2010-08-28 11:20:04 UTC
  • mto: This revision was merged to the branch mainline in revision 5418.
  • Revision ID: jelmer@samba.org-20100828112004-83vag2ktvihjlt40
Fix some test failures now that bzrlib.controldir.network_format_registry has moved.

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
32
32
    bzrdir,
33
33
    directory_service,
34
34
    delta,
35
 
    config as _mod_config,
 
35
    config,
36
36
    errors,
37
37
    globbing,
38
38
    hooks,
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
 
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
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
 
1061
994
                view_info=view_info)
1062
995
            result = tree_to.pull(
1063
996
                branch_from, overwrite, revision_id, change_reporter,
1064
 
                possible_transports=possible_transports, local=local,
1065
 
                show_base=show_base)
 
997
                possible_transports=possible_transports, local=local)
1066
998
        else:
1067
999
            result = branch_to.pull(
1068
1000
                branch_from, overwrite, revision_id, local=local)
1072
1004
            log.show_branch_change(
1073
1005
                branch_to, self.outf, result.old_revno,
1074
1006
                result.old_revid)
1075
 
        if getattr(result, 'tag_conflicts', None):
1076
 
            return 1
1077
 
        else:
1078
 
            return 0
1079
1007
 
1080
1008
 
1081
1009
class cmd_push(Command):
1128
1056
        Option('strict',
1129
1057
               help='Refuse to push if there are uncommitted changes in'
1130
1058
               ' the working tree, --no-strict disables the check.'),
1131
 
        Option('no-tree',
1132
 
               help="Don't populate the working tree, even for protocols"
1133
 
               " that support it."),
1134
1059
        ]
1135
1060
    takes_args = ['location?']
1136
1061
    encoding_type = 'replace'
1138
1063
    def run(self, location=None, remember=False, overwrite=False,
1139
1064
        create_prefix=False, verbose=False, revision=None,
1140
1065
        use_existing_dir=False, directory=None, stacked_on=None,
1141
 
        stacked=False, strict=None, no_tree=False):
 
1066
        stacked=False, strict=None):
1142
1067
        from bzrlib.push import _show_push_branch
1143
1068
 
1144
1069
        if directory is None:
1190
1115
        _show_push_branch(br_from, revision_id, location, self.outf,
1191
1116
            verbose=verbose, overwrite=overwrite, remember=remember,
1192
1117
            stacked_on=stacked_on, create_prefix=create_prefix,
1193
 
            use_existing_dir=use_existing_dir, no_tree=no_tree)
 
1118
            use_existing_dir=use_existing_dir)
1194
1119
 
1195
1120
 
1196
1121
class cmd_branch(Command):
1205
1130
 
1206
1131
    To retrieve the branch as of a particular revision, supply the --revision
1207
1132
    parameter, as in "branch foo/bar -r 5".
1208
 
 
1209
 
    The synonyms 'clone' and 'get' for this command are deprecated.
1210
1133
    """
1211
1134
 
1212
1135
    _see_also = ['checkout']
1242
1165
            files_from=None):
1243
1166
        from bzrlib import switch as _mod_switch
1244
1167
        from bzrlib.tag import _merge_tags_if_possible
1245
 
        if self.invoked_as in ['get', 'clone']:
1246
 
            ui.ui_factory.show_user_warning(
1247
 
                'deprecated_command',
1248
 
                deprecated_name=self.invoked_as,
1249
 
                recommended_name='branch',
1250
 
                deprecated_in_version='2.4')
1251
1168
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1252
1169
            from_location)
1253
1170
        if not (hardlink or files_from):
1437
1354
    If you want to discard your local changes, you can just do a
1438
1355
    'bzr revert' instead of 'bzr commit' after the update.
1439
1356
 
1440
 
    If you want to restore a file that has been removed locally, use
1441
 
    'bzr revert' instead of 'bzr update'.
1442
 
 
1443
1357
    If the tree's branch is bound to a master branch, it will also update
1444
1358
    the branch from the master.
1445
1359
    """
1446
1360
 
1447
1361
    _see_also = ['pull', 'working-trees', 'status-flags']
1448
1362
    takes_args = ['dir?']
1449
 
    takes_options = ['revision',
1450
 
                     Option('show-base',
1451
 
                            help="Show base revision text in conflicts."),
1452
 
                     ]
 
1363
    takes_options = ['revision']
1453
1364
    aliases = ['up']
1454
1365
 
1455
 
    def run(self, dir='.', revision=None, show_base=None):
 
1366
    def run(self, dir='.', revision=None):
1456
1367
        if revision is not None and len(revision) != 1:
1457
1368
            raise errors.BzrCommandError(
1458
1369
                        "bzr update --revision takes exactly one revision")
1498
1409
                change_reporter,
1499
1410
                possible_transports=possible_transports,
1500
1411
                revision=revision_id,
1501
 
                old_tip=old_tip,
1502
 
                show_base=show_base)
 
1412
                old_tip=old_tip)
1503
1413
        except errors.NoSuchRevision, e:
1504
1414
            raise errors.BzrCommandError(
1505
1415
                                  "branch has no revision %s\n"
1581
1491
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1582
1492
            safe='Backup changed files (default).',
1583
1493
            keep='Delete from bzr but leave the working copy.',
1584
 
            no_backup='Don\'t backup changed files.',
1585
1494
            force='Delete all the specified files, even if they can not be '
1586
 
                'recovered and even if they are non-empty directories. '
1587
 
                '(deprecated, use no-backup)')]
 
1495
                'recovered and even if they are non-empty directories.')]
1588
1496
    aliases = ['rm', 'del']
1589
1497
    encoding_type = 'replace'
1590
1498
 
1591
1499
    def run(self, file_list, verbose=False, new=False,
1592
1500
        file_deletion_strategy='safe'):
1593
 
        if file_deletion_strategy == 'force':
1594
 
            note("(The --force option is deprecated, rather use --no-backup "
1595
 
                "in future.)")
1596
 
            file_deletion_strategy = 'no-backup'
1597
 
 
1598
1501
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1599
1502
 
1600
1503
        if file_list is not None:
1621
1524
            file_deletion_strategy = 'keep'
1622
1525
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1623
1526
            keep_files=file_deletion_strategy=='keep',
1624
 
            force=(file_deletion_strategy=='no-backup'))
 
1527
            force=file_deletion_strategy=='force')
1625
1528
 
1626
1529
 
1627
1530
class cmd_file_id(Command):
1782
1685
                ),
1783
1686
         Option('append-revisions-only',
1784
1687
                help='Never change revnos or the existing log.'
1785
 
                '  Append revisions to it only.'),
1786
 
         Option('no-tree',
1787
 
                'Create a branch without a working tree.')
 
1688
                '  Append revisions to it only.')
1788
1689
         ]
1789
1690
    def run(self, location=None, format=None, append_revisions_only=False,
1790
 
            create_prefix=False, no_tree=False):
 
1691
            create_prefix=False):
1791
1692
        if format is None:
1792
1693
            format = bzrdir.format_registry.make_bzrdir('default')
1793
1694
        if location is None:
1816
1717
        except errors.NotBranchError:
1817
1718
            # really a NotBzrDir error...
1818
1719
            create_branch = bzrdir.BzrDir.create_branch_convenience
1819
 
            if no_tree:
1820
 
                force_new_tree = False
1821
 
            else:
1822
 
                force_new_tree = None
1823
1720
            branch = create_branch(to_transport.base, format=format,
1824
 
                                   possible_transports=[to_transport],
1825
 
                                   force_new_tree=force_new_tree)
 
1721
                                   possible_transports=[to_transport])
1826
1722
            a_bzrdir = branch.bzrdir
1827
1723
        else:
1828
1724
            from bzrlib.transport.local import LocalTransport
1832
1728
                        raise errors.BranchExistsWithoutWorkingTree(location)
1833
1729
                raise errors.AlreadyBranchError(location)
1834
1730
            branch = a_bzrdir.create_branch()
1835
 
            if not no_tree:
1836
 
                a_bzrdir.create_workingtree()
 
1731
            a_bzrdir.create_workingtree()
1837
1732
        if append_revisions_only:
1838
1733
            try:
1839
1734
                branch.set_append_revisions_only(True)
1933
1828
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1934
1829
    produces patches suitable for "patch -p1".
1935
1830
 
1936
 
    Note that when using the -r argument with a range of revisions, the
1937
 
    differences are computed between the two specified revisions.  That
1938
 
    is, the command does not show the changes introduced by the first 
1939
 
    revision in the range.  This differs from the interpretation of 
1940
 
    revision ranges used by "bzr log" which includes the first revision
1941
 
    in the range.
1942
 
 
1943
1831
    :Exit values:
1944
1832
        1 - changed
1945
1833
        2 - unrepresentable changes
1963
1851
 
1964
1852
            bzr diff -r1..3 xxx
1965
1853
 
1966
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
1967
 
 
1968
 
            bzr diff -c2
1969
 
 
1970
 
        To see the changes introduced by revision X::
 
1854
        To see the changes introduced in revision X::
1971
1855
        
1972
1856
            bzr diff -cX
1973
1857
 
1977
1861
 
1978
1862
            bzr diff -r<chosen_parent>..X
1979
1863
 
1980
 
        The changes between the current revision and the previous revision
1981
 
        (equivalent to -c-1 and -r-2..-1)
 
1864
        The changes introduced by revision 2 (equivalent to -r1..2)::
1982
1865
 
1983
 
            bzr diff -r-2..
 
1866
            bzr diff -c2
1984
1867
 
1985
1868
        Show just the differences for file NEWS::
1986
1869
 
2030
1913
            type=unicode,
2031
1914
            ),
2032
1915
        RegistryOption('format',
2033
 
            short_name='F',
2034
1916
            help='Diff format to use.',
2035
1917
            lazy_registry=('bzrlib.diff', 'format_registry'),
2036
 
            title='Diff format'),
 
1918
            value_switches=False, title='Diff format'),
2037
1919
        ]
2038
1920
    aliases = ['di', 'dif']
2039
1921
    encoding_type = 'exact'
2120
2002
    @display_command
2121
2003
    def run(self, null=False, directory=u'.'):
2122
2004
        tree = WorkingTree.open_containing(directory)[0]
2123
 
        self.add_cleanup(tree.lock_read().unlock)
2124
2005
        td = tree.changes_from(tree.basis_tree())
2125
 
        self.cleanup_now()
2126
2006
        for path, id, kind, text_modified, meta_modified in td.modified:
2127
2007
            if null:
2128
2008
                self.outf.write(path + '\0')
2758
2638
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2759
2639
    precedence over the '!' exception patterns.
2760
2640
 
2761
 
    :Notes: 
2762
 
        
2763
 
    * Ignore patterns containing shell wildcards must be quoted from
2764
 
      the shell on Unix.
2765
 
 
2766
 
    * Ignore patterns starting with "#" act as comments in the ignore file.
2767
 
      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.
2768
2643
 
2769
2644
    :Examples:
2770
2645
        Ignore the top level Makefile::
2779
2654
 
2780
2655
            bzr ignore "!special.class"
2781
2656
 
2782
 
        Ignore files whose name begins with the "#" character::
2783
 
 
2784
 
            bzr ignore "RE:^#"
2785
 
 
2786
2657
        Ignore .o files under the lib directory::
2787
2658
 
2788
2659
            bzr ignore "lib/**/*.o"
2796
2667
            bzr ignore "RE:(?!debian/).*"
2797
2668
        
2798
2669
        Ignore everything except the "local" toplevel directory,
2799
 
        but always ignore autosave files ending in ~, even under local/::
 
2670
        but always ignore "*~" autosave files, even under local/::
2800
2671
        
2801
2672
            bzr ignore "*"
2802
2673
            bzr ignore "!./local"
2930
2801
         zip                          .zip
2931
2802
      =================       =========================
2932
2803
    """
2933
 
    encoding = 'exact'
2934
2804
    takes_args = ['dest', 'branch_or_subdir?']
2935
2805
    takes_options = ['directory',
2936
2806
        Option('format',
3114
2984
      to trigger updates to external systems like bug trackers. The --fixes
3115
2985
      option can be used to record the association between a revision and
3116
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.)
3117
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
3118
3013
 
3119
3014
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3120
3015
    takes_args = ['selected*']
3152
3047
             Option('show-diff', short_name='p',
3153
3048
                    help='When no message is supplied, show the diff along'
3154
3049
                    ' with the status summary in the message editor.'),
3155
 
             Option('lossy', 
3156
 
                    help='When committing to a foreign version control '
3157
 
                    'system do not push data that can not be natively '
3158
 
                    'represented.'),
3159
3050
             ]
3160
3051
    aliases = ['ci', 'checkin']
3161
3052
 
3180
3071
 
3181
3072
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3182
3073
            unchanged=False, strict=False, local=False, fixes=None,
3183
 
            author=None, show_diff=False, exclude=None, commit_time=None,
3184
 
            lossy=False):
 
3074
            author=None, show_diff=False, exclude=None, commit_time=None):
3185
3075
        from bzrlib.errors import (
3186
3076
            PointlessCommit,
3187
3077
            ConflictsInTree,
3201
3091
                raise errors.BzrCommandError(
3202
3092
                    "Could not parse --commit-time: " + str(e))
3203
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
 
3204
3100
        properties = {}
3205
3101
 
3206
3102
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3283
3179
                        reporter=None, verbose=verbose, revprops=properties,
3284
3180
                        authors=author, timestamp=commit_stamp,
3285
3181
                        timezone=offset,
3286
 
                        exclude=tree.safe_relpath_files(exclude),
3287
 
                        lossy=lossy)
 
3182
                        exclude=tree.safe_relpath_files(exclude))
3288
3183
        except PointlessCommit:
3289
3184
            raise errors.BzrCommandError("No changes to commit."
3290
 
                " Please 'bzr add' the files you want to commit, or use"
3291
 
                " --unchanged to force an empty commit.")
 
3185
                              " Use --unchanged to commit anyhow.")
3292
3186
        except ConflictsInTree:
3293
3187
            raise errors.BzrCommandError('Conflicts detected in working '
3294
3188
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3375
3269
 
3376
3270
 
3377
3271
class cmd_upgrade(Command):
3378
 
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
3379
 
 
3380
 
    When the default format has changed after a major new release of
3381
 
    Bazaar, you may be informed during certain operations that you
3382
 
    should upgrade. Upgrading to a newer format may improve performance
3383
 
    or make new features available. It may however limit interoperability
3384
 
    with older repositories or with older versions of Bazaar.
3385
 
 
3386
 
    If you wish to upgrade to a particular format rather than the
3387
 
    current default, that can be specified using the --format option.
3388
 
    As a consequence, you can use the upgrade command this way to
3389
 
    "downgrade" to an earlier format, though some conversions are
3390
 
    a one way process (e.g. changing from the 1.x default to the
3391
 
    2.x default) so downgrading is not always possible.
3392
 
 
3393
 
    A backup.bzr.~#~ directory is created at the start of the conversion
3394
 
    process (where # is a number). By default, this is left there on
3395
 
    completion. If the conversion fails, delete the new .bzr directory
3396
 
    and rename this one back in its place. Use the --clean option to ask
3397
 
    for the backup.bzr directory to be removed on successful conversion.
3398
 
    Alternatively, you can delete it by hand if everything looks good
3399
 
    afterwards.
3400
 
 
3401
 
    If the location given is a shared repository, dependent branches
3402
 
    are also converted provided the repository converts successfully.
3403
 
    If the conversion of a branch fails, remaining branches are still
3404
 
    tried.
3405
 
 
3406
 
    For more information on upgrades, see the Bazaar Upgrade Guide,
3407
 
    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.
3408
3277
    """
3409
3278
 
3410
 
    _see_also = ['check', 'reconcile', 'formats']
 
3279
    _see_also = ['check']
3411
3280
    takes_args = ['url?']
3412
3281
    takes_options = [
3413
 
        RegistryOption('format',
3414
 
            help='Upgrade to a specific format.  See "bzr help'
3415
 
                 ' formats" for details.',
3416
 
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3417
 
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3418
 
            value_switches=True, title='Branch format'),
3419
 
        Option('clean',
3420
 
            help='Remove the backup.bzr directory if successful.'),
3421
 
        Option('dry-run',
3422
 
            help="Show what would be done, but don't actually do anything."),
3423
 
    ]
 
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
                    ]
3424
3289
 
3425
 
    def run(self, url='.', format=None, clean=False, dry_run=False):
 
3290
    def run(self, url='.', format=None):
3426
3291
        from bzrlib.upgrade import upgrade
3427
 
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3428
 
        if exceptions:
3429
 
            if len(exceptions) == 1:
3430
 
                # Compatibility with historical behavior
3431
 
                raise exceptions[0]
3432
 
            else:
3433
 
                return 3
 
3292
        upgrade(url, format)
3434
3293
 
3435
3294
 
3436
3295
class cmd_whoami(Command):
3463
3322
                try:
3464
3323
                    c = Branch.open_containing(u'.')[0].get_config()
3465
3324
                except errors.NotBranchError:
3466
 
                    c = _mod_config.GlobalConfig()
 
3325
                    c = config.GlobalConfig()
3467
3326
            else:
3468
3327
                c = Branch.open(directory).get_config()
3469
3328
            if email:
3472
3331
                self.outf.write(c.username() + '\n')
3473
3332
            return
3474
3333
 
3475
 
        if email:
3476
 
            raise errors.BzrCommandError("--email can only be used to display existing "
3477
 
                                         "identity")
3478
 
 
3479
3334
        # display a warning if an email address isn't included in the given name.
3480
3335
        try:
3481
 
            _mod_config.extract_email_address(name)
 
3336
            config.extract_email_address(name)
3482
3337
        except errors.NoEmailInUsername, e:
3483
3338
            warning('"%s" does not seem to contain an email address.  '
3484
3339
                    'This is allowed, but not recommended.', name)
3490
3345
            else:
3491
3346
                c = Branch.open(directory).get_config()
3492
3347
        else:
3493
 
            c = _mod_config.GlobalConfig()
 
3348
            c = config.GlobalConfig()
3494
3349
        c.set_user_option('email', name)
3495
3350
 
3496
3351
 
3563
3418
                'bzr alias --remove expects an alias to remove.')
3564
3419
        # If alias is not found, print something like:
3565
3420
        # unalias: foo: not found
3566
 
        c = _mod_config.GlobalConfig()
 
3421
        c = config.GlobalConfig()
3567
3422
        c.unset_alias(alias_name)
3568
3423
 
3569
3424
    @display_command
3570
3425
    def print_aliases(self):
3571
3426
        """Print out the defined aliases in a similar format to bash."""
3572
 
        aliases = _mod_config.GlobalConfig().get_aliases()
 
3427
        aliases = config.GlobalConfig().get_aliases()
3573
3428
        for key, value in sorted(aliases.iteritems()):
3574
3429
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3575
3430
 
3585
3440
 
3586
3441
    def set_alias(self, alias_name, alias_command):
3587
3442
        """Save the alias in the global config."""
3588
 
        c = _mod_config.GlobalConfig()
 
3443
        c = config.GlobalConfig()
3589
3444
        c.set_alias(alias_name, alias_command)
3590
3445
 
3591
3446
 
3626
3481
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3627
3482
    into a pdb postmortem session.
3628
3483
 
3629
 
    The --coverage=DIRNAME global option produces a report with covered code
3630
 
    indicated.
3631
 
 
3632
3484
    :Examples:
3633
3485
        Run only tests relating to 'ignore'::
3634
3486
 
3718
3570
            randomize=None, exclude=None, strict=False,
3719
3571
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3720
3572
            parallel=None, lsprof_tests=False):
3721
 
        from bzrlib import tests
 
3573
        from bzrlib.tests import selftest
 
3574
 
 
3575
        # Make deprecation warnings visible, unless -Werror is set
 
3576
        symbol_versioning.activate_deprecation_warnings(override=False)
3722
3577
 
3723
3578
        if testspecs_list is not None:
3724
3579
            pattern = '|'.join(testspecs_list)
3765
3620
                          "starting_with": starting_with
3766
3621
                          }
3767
3622
        selftest_kwargs.update(self.additional_selftest_args)
3768
 
 
3769
 
        # Make deprecation warnings visible, unless -Werror is set
3770
 
        cleanup = symbol_versioning.activate_deprecation_warnings(
3771
 
            override=False)
3772
 
        try:
3773
 
            result = tests.selftest(**selftest_kwargs)
3774
 
        finally:
3775
 
            cleanup()
 
3623
        result = selftest(**selftest_kwargs)
3776
3624
        return int(not result)
3777
3625
 
3778
3626
 
3835
3683
    with bzr send. If neither is specified, the default is the upstream branch
3836
3684
    or the branch most recently merged using --remember.
3837
3685
 
3838
 
    When merging from a branch, by default bzr will try to merge in all new
3839
 
    work from the other branch, automatically determining an appropriate base
3840
 
    revision.  If this fails, you may need to give an explicit base.
3841
 
 
3842
 
    To pick a different ending revision, pass "--revision OTHER".  bzr will
3843
 
    try to merge in all new work up to and including revision OTHER.
3844
 
 
3845
 
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
3846
 
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
3847
 
    causes some revisions to be skipped, i.e. if the destination branch does
3848
 
    not already contain revision BASE, such a merge is commonly referred to as
3849
 
    a "cherrypick".
3850
 
 
3851
 
    Revision numbers are always relative to the source branch.
 
3686
    When merging a branch, by default the tip will be merged. To pick a different
 
3687
    revision, pass --revision. If you specify two values, the first will be used as
 
3688
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
 
3689
    available revisions, like this is commonly referred to as "cherrypicking".
 
3690
 
 
3691
    Revision numbers are always relative to the branch being merged.
 
3692
 
 
3693
    By default, bzr will try to merge in all new work from the other
 
3694
    branch, automatically determining an appropriate base.  If this
 
3695
    fails, you may need to give an explicit base.
3852
3696
 
3853
3697
    Merge will do its best to combine the changes in two branches, but there
3854
3698
    are some kinds of problems only a human can fix.  When it encounters those,
3878
3722
    you to apply each diff hunk and file change, similar to "shelve".
3879
3723
 
3880
3724
    :Examples:
3881
 
        To merge all new revisions from bzr.dev::
 
3725
        To merge the latest revision from bzr.dev::
3882
3726
 
3883
3727
            bzr merge ../bzr.dev
3884
3728
 
3999
3843
            merger.other_rev_id is not None):
4000
3844
            note('Nothing to do.')
4001
3845
            return 0
4002
 
        if pull and not preview:
 
3846
        if pull:
4003
3847
            if merger.interesting_files is not None:
4004
3848
                raise errors.BzrCommandError('Cannot pull individual files')
4005
3849
            if (merger.base_rev_id == tree.last_revision()):
4118
3962
        if ((remember or tree.branch.get_submit_branch() is None) and
4119
3963
             user_location is not None):
4120
3964
            tree.branch.set_submit_branch(other_branch.base)
4121
 
        # Merge tags (but don't set them in the master branch yet, the user
4122
 
        # might revert this merge).  Commit will propagate them.
4123
 
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
 
3965
        _merge_tags_if_possible(other_branch, tree.branch)
4124
3966
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
4125
3967
            other_revision_id, base_revision_id, other_branch, base_branch)
4126
3968
        if other_path != '':
4294
4136
    last committed revision is used.
4295
4137
 
4296
4138
    To remove only some changes, without reverting to a prior version, use
4297
 
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
4298
 
    will remove the changes introduced by the second last commit (-2), without
4299
 
    affecting the changes introduced by the last commit (-1).  To remove
4300
 
    certain changes on a hunk-by-hunk basis, see the shelve command.
 
4139
    merge instead.  For example, "merge . --revision -2..-3" will remove the
 
4140
    changes introduced by -2, without affecting the changes introduced by -1.
 
4141
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
4301
4142
 
4302
4143
    By default, any files that have been manually changed will be backed up
4303
4144
    first.  (Files changed only by merge are not backed up.)  Backup files have
4333
4174
    target branches.
4334
4175
    """
4335
4176
 
4336
 
    _see_also = ['cat', 'export', 'merge', 'shelve']
 
4177
    _see_also = ['cat', 'export']
4337
4178
    takes_options = [
4338
4179
        'revision',
4339
4180
        Option('no-backup', "Do not save backups of reverted files."),
4632
4473
 
4633
4474
    @display_command
4634
4475
    def run(self, verbose=False):
4635
 
        from bzrlib import plugin
4636
 
        self.outf.writelines(
4637
 
            plugin.describe_plugins(show_paths=verbose))
 
4476
        import bzrlib.plugin
 
4477
        from inspect import getdoc
 
4478
        result = []
 
4479
        for name, plugin in bzrlib.plugin.plugins().items():
 
4480
            version = plugin.__version__
 
4481
            if version == 'unknown':
 
4482
                version = ''
 
4483
            name_ver = '%s %s' % (name, version)
 
4484
            d = getdoc(plugin.module)
 
4485
            if d:
 
4486
                doc = d.split('\n')[0]
 
4487
            else:
 
4488
                doc = '(no description)'
 
4489
            result.append((name_ver, doc, plugin.path()))
 
4490
        for name_ver, doc, path in sorted(result):
 
4491
            self.outf.write("%s\n" % name_ver)
 
4492
            self.outf.write("   %s\n" % doc)
 
4493
            if verbose:
 
4494
                self.outf.write("   %s\n" % path)
 
4495
            self.outf.write("\n")
4638
4496
 
4639
4497
 
4640
4498
class cmd_testament(Command):
4702
4560
            self.add_cleanup(branch.lock_read().unlock)
4703
4561
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4704
4562
        self.add_cleanup(tree.lock_read().unlock)
4705
 
        if wt is not None and revision is None:
 
4563
        if wt is not None:
4706
4564
            file_id = wt.path2id(relpath)
4707
4565
        else:
4708
4566
            file_id = tree.path2id(relpath)
4709
4567
        if file_id is None:
4710
4568
            raise errors.NotVersionedError(filename)
 
4569
        file_version = tree.inventory[file_id].revision
4711
4570
        if wt is not None and revision is None:
4712
4571
            # If there is a tree and we're not annotating historical
4713
4572
            # versions, annotate the working tree's content.
4714
4573
            annotate_file_tree(wt, file_id, self.outf, long, all,
4715
4574
                show_ids=show_ids)
4716
4575
        else:
4717
 
            file_version = tree.get_file_revision(file_id)
4718
4576
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4719
4577
                          show_ids=show_ids)
4720
4578
 
4936
4794
            self.outf.write('The above revision(s) will be removed.\n')
4937
4795
 
4938
4796
        if not force:
4939
 
            if not ui.ui_factory.confirm_action(
4940
 
                    'Uncommit these revisions',
4941
 
                    'bzrlib.builtins.uncommit',
4942
 
                    {}):
4943
 
                self.outf.write('Canceled\n')
 
4797
            if not ui.ui_factory.get_boolean('Are you sure'):
 
4798
                self.outf.write('Canceled')
4944
4799
                return 0
4945
4800
 
4946
4801
        mutter('Uncommitting from {%s} to {%s}',
4952
4807
 
4953
4808
 
4954
4809
class cmd_break_lock(Command):
4955
 
    __doc__ = """Break a dead lock.
4956
 
 
4957
 
    This command breaks a lock on a repository, branch, working directory or
4958
 
    config file.
 
4810
    __doc__ = """Break a dead lock on a repository, branch or working directory.
4959
4811
 
4960
4812
    CAUTION: Locks should only be broken when you are sure that the process
4961
4813
    holding the lock has been stopped.
4966
4818
    :Examples:
4967
4819
        bzr break-lock
4968
4820
        bzr break-lock bzr+ssh://example.com/bzr/foo
4969
 
        bzr break-lock --conf ~/.bazaar
4970
4821
    """
4971
 
 
4972
4822
    takes_args = ['location?']
4973
 
    takes_options = [
4974
 
        Option('config',
4975
 
               help='LOCATION is the directory where the config lock is.'),
4976
 
        Option('force',
4977
 
            help='Do not ask for confirmation before breaking the lock.'),
4978
 
        ]
4979
4823
 
4980
 
    def run(self, location=None, config=False, force=False):
 
4824
    def run(self, location=None, show=False):
4981
4825
        if location is None:
4982
4826
            location = u'.'
4983
 
        if force:
4984
 
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
4985
 
                None,
4986
 
                {'bzrlib.lockdir.break': True})
4987
 
        if config:
4988
 
            conf = _mod_config.LockableConfig(file_name=location)
4989
 
            conf.break_lock()
4990
 
        else:
4991
 
            control, relpath = bzrdir.BzrDir.open_containing(location)
4992
 
            try:
4993
 
                control.break_lock()
4994
 
            except NotImplementedError:
4995
 
                pass
 
4827
        control, relpath = bzrdir.BzrDir.open_containing(location)
 
4828
        try:
 
4829
            control.break_lock()
 
4830
        except NotImplementedError:
 
4831
            pass
4996
4832
 
4997
4833
 
4998
4834
class cmd_wait_until_signalled(Command):
5083
4919
    not part of it.  (Such trees can be produced by "bzr split", but also by
5084
4920
    running "bzr branch" with the target inside a tree.)
5085
4921
 
5086
 
    The result is a combined tree, with the subtree no longer an independent
 
4922
    The result is a combined tree, with the subtree no longer an independant
5087
4923
    part.  This is marked as a merge of the subtree into the containing tree,
5088
4924
    and all history is preserved.
5089
4925
    """
5485
5321
            if tag_name is None:
5486
5322
                raise errors.BzrCommandError("No tag specified to delete.")
5487
5323
            branch.tags.delete_tag(tag_name)
5488
 
            note('Deleted tag %s.' % tag_name)
 
5324
            self.outf.write('Deleted tag %s.\n' % tag_name)
5489
5325
        else:
5490
5326
            if revision:
5491
5327
                if len(revision) != 1:
5503
5339
            if (not force) and branch.tags.has_tag(tag_name):
5504
5340
                raise errors.TagAlreadyExists(tag_name)
5505
5341
            branch.tags.set_tag(tag_name, revision_id)
5506
 
            note('Created tag %s.' % tag_name)
 
5342
            self.outf.write('Created tag %s.\n' % tag_name)
5507
5343
 
5508
5344
 
5509
5345
class cmd_tags(Command):
5516
5352
    takes_options = [
5517
5353
        custom_help('directory',
5518
5354
            help='Branch whose tags should be displayed.'),
5519
 
        RegistryOption('sort',
 
5355
        RegistryOption.from_kwargs('sort',
5520
5356
            'Sort tags by different criteria.', title='Sorting',
5521
 
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
 
5357
            alpha='Sort tags lexicographically (default).',
 
5358
            time='Sort tags chronologically.',
5522
5359
            ),
5523
5360
        'show-ids',
5524
5361
        'revision',
5525
5362
    ]
5526
5363
 
5527
5364
    @display_command
5528
 
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
5529
 
        from bzrlib.tag import tag_sort_methods
 
5365
    def run(self,
 
5366
            directory='.',
 
5367
            sort='alpha',
 
5368
            show_ids=False,
 
5369
            revision=None,
 
5370
            ):
5530
5371
        branch, relpath = Branch.open_containing(directory)
5531
5372
 
5532
5373
        tags = branch.tags.get_tag_dict().items()
5541
5382
            # only show revisions between revid1 and revid2 (inclusive)
5542
5383
            tags = [(tag, revid) for tag, revid in tags if
5543
5384
                graph.is_between(revid, revid1, revid2)]
5544
 
        if sort is None:
5545
 
            sort = tag_sort_methods.get()
5546
 
        sort(branch, tags)
 
5385
        if sort == 'alpha':
 
5386
            tags.sort()
 
5387
        elif sort == 'time':
 
5388
            timestamps = {}
 
5389
            for tag, revid in tags:
 
5390
                try:
 
5391
                    revobj = branch.repository.get_revision(revid)
 
5392
                except errors.NoSuchRevision:
 
5393
                    timestamp = sys.maxint # place them at the end
 
5394
                else:
 
5395
                    timestamp = revobj.timestamp
 
5396
                timestamps[revid] = timestamp
 
5397
            tags.sort(key=lambda x: timestamps[x[1]])
5547
5398
        if not show_ids:
5548
5399
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5549
5400
            for index, (tag, revid) in enumerate(tags):
5551
5402
                    revno = branch.revision_id_to_dotted_revno(revid)
5552
5403
                    if isinstance(revno, tuple):
5553
5404
                        revno = '.'.join(map(str, revno))
5554
 
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
 
5405
                except errors.NoSuchRevision:
5555
5406
                    # Bad tag data/merges can lead to tagged revisions
5556
5407
                    # which are not in this branch. Fail gracefully ...
5557
5408
                    revno = '?'
5947
5798
            location = "."
5948
5799
        branch = Branch.open_containing(location)[0]
5949
5800
        branch.bzrdir.destroy_branch()
5950
 
 
 
5801
        
5951
5802
 
5952
5803
class cmd_shelve(Command):
5953
5804
    __doc__ = """Temporarily set aside some changes from the current tree.
5972
5823
 
5973
5824
    You can put multiple items on the shelf, and by default, 'unshelve' will
5974
5825
    restore the most recently shelved changes.
5975
 
 
5976
 
    For complicated changes, it is possible to edit the changes in a separate
5977
 
    editor program to decide what the file remaining in the working copy
5978
 
    should look like.  To do this, add the configuration option
5979
 
 
5980
 
        change_editor = PROGRAM @new_path @old_path
5981
 
 
5982
 
    where @new_path is replaced with the path of the new version of the 
5983
 
    file and @old_path is replaced with the path of the old version of 
5984
 
    the file.  The PROGRAM should save the new file with the desired 
5985
 
    contents of the file in the working tree.
5986
 
        
5987
5826
    """
5988
5827
 
5989
5828
    takes_args = ['file*']
6001
5840
        Option('destroy',
6002
5841
               help='Destroy removed changes instead of shelving them.'),
6003
5842
    ]
6004
 
    _see_also = ['unshelve', 'configuration']
 
5843
    _see_also = ['unshelve']
6005
5844
 
6006
5845
    def run(self, revision=None, all=False, file_list=None, message=None,
6007
 
            writer=None, list=False, destroy=False, directory=None):
 
5846
            writer=None, list=False, destroy=False, directory=u'.'):
6008
5847
        if list:
6009
 
            return self.run_for_list(directory=directory)
 
5848
            return self.run_for_list()
6010
5849
        from bzrlib.shelf_ui import Shelver
6011
5850
        if writer is None:
6012
5851
            writer = bzrlib.option.diff_writer_registry.get()
6020
5859
        except errors.UserAbort:
6021
5860
            return 0
6022
5861
 
6023
 
    def run_for_list(self, directory=None):
6024
 
        if directory is None:
6025
 
            directory = u'.'
6026
 
        tree = WorkingTree.open_containing(directory)[0]
 
5862
    def run_for_list(self):
 
5863
        tree = WorkingTree.open_containing('.')[0]
6027
5864
        self.add_cleanup(tree.lock_read().unlock)
6028
5865
        manager = tree.get_shelf_manager()
6029
5866
        shelves = manager.active_shelves()
6088
5925
    """
6089
5926
    takes_options = ['directory',
6090
5927
                     Option('ignored', help='Delete all ignored files.'),
6091
 
                     Option('detritus', help='Delete conflict files, merge and revert'
 
5928
                     Option('detritus', help='Delete conflict files, merge'
6092
5929
                            ' backups, and failed selftest dirs.'),
6093
5930
                     Option('unknown',
6094
5931
                            help='Delete files unknown to bzr (default).'),
6158
5995
    # be only called once.
6159
5996
    for (name, aliases, module_name) in [
6160
5997
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6161
 
        ('cmd_config', [], 'bzrlib.config'),
6162
5998
        ('cmd_dpush', [], 'bzrlib.foreign'),
6163
5999
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6164
6000
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6165
6001
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6166
6002
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6167
 
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6168
6003
        ]:
6169
6004
        builtin_command_registry.register_lazy(name, aliases, module_name)