~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
 
    If a revision argument is given, the status is calculated against
254
 
    that revision, or between two revisions if two are provided.
 
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'.
255
259
    """
256
260
 
257
261
    # TODO: --no-recurse, --recurse options
324
328
        if revision_id is None and revision is None:
325
329
            raise errors.BzrCommandError('You must supply either'
326
330
                                         ' --revision or a revision_id')
327
 
        b = WorkingTree.open_containing(directory)[0].branch
 
331
 
 
332
        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
328
333
 
329
334
        revisions = b.repository.revisions
330
335
        if revisions is None:
408
413
                self.outf.write(page_bytes[:header_end])
409
414
                page_bytes = data
410
415
            self.outf.write('\nPage %d\n' % (page_idx,))
411
 
            decomp_bytes = zlib.decompress(page_bytes)
412
 
            self.outf.write(decomp_bytes)
413
 
            self.outf.write('\n')
 
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')
414
422
 
415
423
    def _dump_entries(self, trans, basename):
416
424
        try:
477
485
            d.destroy_workingtree()
478
486
 
479
487
 
 
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
 
480
541
class cmd_revno(Command):
481
542
    __doc__ = """Show current revision number.
482
543
 
923
984
                 "branch.  Local pulls are not applied to "
924
985
                 "the master branch."
925
986
            ),
 
987
        Option('show-base',
 
988
            help="Show base revision text in conflicts.")
926
989
        ]
927
990
    takes_args = ['location?']
928
991
    encoding_type = 'replace'
929
992
 
930
993
    def run(self, location=None, remember=False, overwrite=False,
931
994
            revision=None, verbose=False,
932
 
            directory=None, local=False):
 
995
            directory=None, local=False,
 
996
            show_base=False):
933
997
        # FIXME: too much stuff is in the command class
934
998
        revision_id = None
935
999
        mergeable = None
944
1008
            branch_to = Branch.open_containing(directory)[0]
945
1009
            self.add_cleanup(branch_to.lock_write().unlock)
946
1010
 
 
1011
        if tree_to is None and show_base:
 
1012
            raise errors.BzrCommandError("Need working tree for --show-base.")
 
1013
 
947
1014
        if local and not branch_to.get_bound_location():
948
1015
            raise errors.LocalRequiresBoundBranch()
949
1016
 
994
1061
                view_info=view_info)
995
1062
            result = tree_to.pull(
996
1063
                branch_from, overwrite, revision_id, change_reporter,
997
 
                possible_transports=possible_transports, local=local)
 
1064
                possible_transports=possible_transports, local=local,
 
1065
                show_base=show_base)
998
1066
        else:
999
1067
            result = branch_to.pull(
1000
1068
                branch_from, overwrite, revision_id, local=local)
1004
1072
            log.show_branch_change(
1005
1073
                branch_to, self.outf, result.old_revno,
1006
1074
                result.old_revid)
 
1075
        if getattr(result, 'tag_conflicts', None):
 
1076
            return 1
 
1077
        else:
 
1078
            return 0
1007
1079
 
1008
1080
 
1009
1081
class cmd_push(Command):
1056
1128
        Option('strict',
1057
1129
               help='Refuse to push if there are uncommitted changes in'
1058
1130
               ' 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."),
1059
1134
        ]
1060
1135
    takes_args = ['location?']
1061
1136
    encoding_type = 'replace'
1063
1138
    def run(self, location=None, remember=False, overwrite=False,
1064
1139
        create_prefix=False, verbose=False, revision=None,
1065
1140
        use_existing_dir=False, directory=None, stacked_on=None,
1066
 
        stacked=False, strict=None):
 
1141
        stacked=False, strict=None, no_tree=False):
1067
1142
        from bzrlib.push import _show_push_branch
1068
1143
 
1069
1144
        if directory is None:
1115
1190
        _show_push_branch(br_from, revision_id, location, self.outf,
1116
1191
            verbose=verbose, overwrite=overwrite, remember=remember,
1117
1192
            stacked_on=stacked_on, create_prefix=create_prefix,
1118
 
            use_existing_dir=use_existing_dir)
 
1193
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1119
1194
 
1120
1195
 
1121
1196
class cmd_branch(Command):
1130
1205
 
1131
1206
    To retrieve the branch as of a particular revision, supply the --revision
1132
1207
    parameter, as in "branch foo/bar -r 5".
 
1208
 
 
1209
    The synonyms 'clone' and 'get' for this command are deprecated.
1133
1210
    """
1134
1211
 
1135
1212
    _see_also = ['checkout']
1165
1242
            files_from=None):
1166
1243
        from bzrlib import switch as _mod_switch
1167
1244
        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')
1168
1251
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1169
1252
            from_location)
1170
1253
        if not (hardlink or files_from):
1354
1437
    If you want to discard your local changes, you can just do a
1355
1438
    'bzr revert' instead of 'bzr commit' after the update.
1356
1439
 
 
1440
    If you want to restore a file that has been removed locally, use
 
1441
    'bzr revert' instead of 'bzr update'.
 
1442
 
1357
1443
    If the tree's branch is bound to a master branch, it will also update
1358
1444
    the branch from the master.
1359
1445
    """
1360
1446
 
1361
1447
    _see_also = ['pull', 'working-trees', 'status-flags']
1362
1448
    takes_args = ['dir?']
1363
 
    takes_options = ['revision']
 
1449
    takes_options = ['revision',
 
1450
                     Option('show-base',
 
1451
                            help="Show base revision text in conflicts."),
 
1452
                     ]
1364
1453
    aliases = ['up']
1365
1454
 
1366
 
    def run(self, dir='.', revision=None):
 
1455
    def run(self, dir='.', revision=None, show_base=None):
1367
1456
        if revision is not None and len(revision) != 1:
1368
1457
            raise errors.BzrCommandError(
1369
1458
                        "bzr update --revision takes exactly one revision")
1409
1498
                change_reporter,
1410
1499
                possible_transports=possible_transports,
1411
1500
                revision=revision_id,
1412
 
                old_tip=old_tip)
 
1501
                old_tip=old_tip,
 
1502
                show_base=show_base)
1413
1503
        except errors.NoSuchRevision, e:
1414
1504
            raise errors.BzrCommandError(
1415
1505
                                  "branch has no revision %s\n"
1491
1581
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1492
1582
            safe='Backup changed files (default).',
1493
1583
            keep='Delete from bzr but leave the working copy.',
 
1584
            no_backup='Don\'t backup changed files.',
1494
1585
            force='Delete all the specified files, even if they can not be '
1495
 
                'recovered and even if they are non-empty directories.')]
 
1586
                'recovered and even if they are non-empty directories. '
 
1587
                '(deprecated, use no-backup)')]
1496
1588
    aliases = ['rm', 'del']
1497
1589
    encoding_type = 'replace'
1498
1590
 
1499
1591
    def run(self, file_list, verbose=False, new=False,
1500
1592
        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
 
1501
1598
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1502
1599
 
1503
1600
        if file_list is not None:
1524
1621
            file_deletion_strategy = 'keep'
1525
1622
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1526
1623
            keep_files=file_deletion_strategy=='keep',
1527
 
            force=file_deletion_strategy=='force')
 
1624
            force=(file_deletion_strategy=='no-backup'))
1528
1625
 
1529
1626
 
1530
1627
class cmd_file_id(Command):
1685
1782
                ),
1686
1783
         Option('append-revisions-only',
1687
1784
                help='Never change revnos or the existing log.'
1688
 
                '  Append revisions to it only.')
 
1785
                '  Append revisions to it only.'),
 
1786
         Option('no-tree',
 
1787
                'Create a branch without a working tree.')
1689
1788
         ]
1690
1789
    def run(self, location=None, format=None, append_revisions_only=False,
1691
 
            create_prefix=False):
 
1790
            create_prefix=False, no_tree=False):
1692
1791
        if format is None:
1693
1792
            format = bzrdir.format_registry.make_bzrdir('default')
1694
1793
        if location is None:
1717
1816
        except errors.NotBranchError:
1718
1817
            # really a NotBzrDir error...
1719
1818
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1819
            if no_tree:
 
1820
                force_new_tree = False
 
1821
            else:
 
1822
                force_new_tree = None
1720
1823
            branch = create_branch(to_transport.base, format=format,
1721
 
                                   possible_transports=[to_transport])
 
1824
                                   possible_transports=[to_transport],
 
1825
                                   force_new_tree=force_new_tree)
1722
1826
            a_bzrdir = branch.bzrdir
1723
1827
        else:
1724
1828
            from bzrlib.transport.local import LocalTransport
1728
1832
                        raise errors.BranchExistsWithoutWorkingTree(location)
1729
1833
                raise errors.AlreadyBranchError(location)
1730
1834
            branch = a_bzrdir.create_branch()
1731
 
            a_bzrdir.create_workingtree()
 
1835
            if not no_tree:
 
1836
                a_bzrdir.create_workingtree()
1732
1837
        if append_revisions_only:
1733
1838
            try:
1734
1839
                branch.set_append_revisions_only(True)
1828
1933
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1829
1934
    produces patches suitable for "patch -p1".
1830
1935
 
 
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
 
1831
1943
    :Exit values:
1832
1944
        1 - changed
1833
1945
        2 - unrepresentable changes
1851
1963
 
1852
1964
            bzr diff -r1..3 xxx
1853
1965
 
1854
 
        To see the changes introduced in revision X::
 
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::
1855
1971
        
1856
1972
            bzr diff -cX
1857
1973
 
1861
1977
 
1862
1978
            bzr diff -r<chosen_parent>..X
1863
1979
 
1864
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1980
        The changes between the current revision and the previous revision
 
1981
        (equivalent to -c-1 and -r-2..-1)
1865
1982
 
1866
 
            bzr diff -c2
 
1983
            bzr diff -r-2..
1867
1984
 
1868
1985
        Show just the differences for file NEWS::
1869
1986
 
1913
2030
            type=unicode,
1914
2031
            ),
1915
2032
        RegistryOption('format',
 
2033
            short_name='F',
1916
2034
            help='Diff format to use.',
1917
2035
            lazy_registry=('bzrlib.diff', 'format_registry'),
1918
 
            value_switches=False, title='Diff format'),
 
2036
            title='Diff format'),
1919
2037
        ]
1920
2038
    aliases = ['di', 'dif']
1921
2039
    encoding_type = 'exact'
2002
2120
    @display_command
2003
2121
    def run(self, null=False, directory=u'.'):
2004
2122
        tree = WorkingTree.open_containing(directory)[0]
 
2123
        self.add_cleanup(tree.lock_read().unlock)
2005
2124
        td = tree.changes_from(tree.basis_tree())
 
2125
        self.cleanup_now()
2006
2126
        for path, id, kind, text_modified, meta_modified in td.modified:
2007
2127
            if null:
2008
2128
                self.outf.write(path + '\0')
2638
2758
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2639
2759
    precedence over the '!' exception patterns.
2640
2760
 
2641
 
    Note: ignore patterns containing shell wildcards must be quoted from
2642
 
    the shell on Unix.
 
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.
2643
2768
 
2644
2769
    :Examples:
2645
2770
        Ignore the top level Makefile::
2654
2779
 
2655
2780
            bzr ignore "!special.class"
2656
2781
 
 
2782
        Ignore files whose name begins with the "#" character::
 
2783
 
 
2784
            bzr ignore "RE:^#"
 
2785
 
2657
2786
        Ignore .o files under the lib directory::
2658
2787
 
2659
2788
            bzr ignore "lib/**/*.o"
2667
2796
            bzr ignore "RE:(?!debian/).*"
2668
2797
        
2669
2798
        Ignore everything except the "local" toplevel directory,
2670
 
        but always ignore "*~" autosave files, even under local/::
 
2799
        but always ignore autosave files ending in ~, even under local/::
2671
2800
        
2672
2801
            bzr ignore "*"
2673
2802
            bzr ignore "!./local"
2801
2930
         zip                          .zip
2802
2931
      =================       =========================
2803
2932
    """
 
2933
    encoding = 'exact'
2804
2934
    takes_args = ['dest', 'branch_or_subdir?']
2805
2935
    takes_options = ['directory',
2806
2936
        Option('format',
2984
3114
      to trigger updates to external systems like bug trackers. The --fixes
2985
3115
      option can be used to record the association between a revision and
2986
3116
      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.)
3004
3117
    """
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
3013
3118
 
3014
3119
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3015
3120
    takes_args = ['selected*']
3047
3152
             Option('show-diff', short_name='p',
3048
3153
                    help='When no message is supplied, show the diff along'
3049
3154
                    ' 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.'),
3050
3159
             ]
3051
3160
    aliases = ['ci', 'checkin']
3052
3161
 
3071
3180
 
3072
3181
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3073
3182
            unchanged=False, strict=False, local=False, fixes=None,
3074
 
            author=None, show_diff=False, exclude=None, commit_time=None):
 
3183
            author=None, show_diff=False, exclude=None, commit_time=None,
 
3184
            lossy=False):
3075
3185
        from bzrlib.errors import (
3076
3186
            PointlessCommit,
3077
3187
            ConflictsInTree,
3091
3201
                raise errors.BzrCommandError(
3092
3202
                    "Could not parse --commit-time: " + str(e))
3093
3203
 
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
 
 
3100
3204
        properties = {}
3101
3205
 
3102
3206
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3179
3283
                        reporter=None, verbose=verbose, revprops=properties,
3180
3284
                        authors=author, timestamp=commit_stamp,
3181
3285
                        timezone=offset,
3182
 
                        exclude=tree.safe_relpath_files(exclude))
 
3286
                        exclude=tree.safe_relpath_files(exclude),
 
3287
                        lossy=lossy)
3183
3288
        except PointlessCommit:
3184
3289
            raise errors.BzrCommandError("No changes to commit."
3185
 
                              " Use --unchanged to commit anyhow.")
 
3290
                " Please 'bzr add' the files you want to commit, or use"
 
3291
                " --unchanged to force an empty commit.")
3186
3292
        except ConflictsInTree:
3187
3293
            raise errors.BzrCommandError('Conflicts detected in working '
3188
3294
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3269
3375
 
3270
3376
 
3271
3377
class cmd_upgrade(Command):
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.
 
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/.
3277
3408
    """
3278
3409
 
3279
 
    _see_also = ['check']
 
3410
    _see_also = ['check', 'reconcile', 'formats']
3280
3411
    takes_args = ['url?']
3281
3412
    takes_options = [
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
 
                    ]
 
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
    ]
3289
3424
 
3290
 
    def run(self, url='.', format=None):
 
3425
    def run(self, url='.', format=None, clean=False, dry_run=False):
3291
3426
        from bzrlib.upgrade import upgrade
3292
 
        upgrade(url, format)
 
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
3293
3434
 
3294
3435
 
3295
3436
class cmd_whoami(Command):
3331
3472
                self.outf.write(c.username() + '\n')
3332
3473
            return
3333
3474
 
 
3475
        if email:
 
3476
            raise errors.BzrCommandError("--email can only be used to display existing "
 
3477
                                         "identity")
 
3478
 
3334
3479
        # display a warning if an email address isn't included in the given name.
3335
3480
        try:
3336
3481
            _mod_config.extract_email_address(name)
3481
3626
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3482
3627
    into a pdb postmortem session.
3483
3628
 
 
3629
    The --coverage=DIRNAME global option produces a report with covered code
 
3630
    indicated.
 
3631
 
3484
3632
    :Examples:
3485
3633
        Run only tests relating to 'ignore'::
3486
3634
 
3687
3835
    with bzr send. If neither is specified, the default is the upstream branch
3688
3836
    or the branch most recently merged using --remember.
3689
3837
 
3690
 
    When merging a branch, by default the tip will be merged. To pick a different
3691
 
    revision, pass --revision. If you specify two values, the first will be used as
3692
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3693
 
    available revisions, like this is commonly referred to as "cherrypicking".
3694
 
 
3695
 
    Revision numbers are always relative to the branch being merged.
3696
 
 
3697
 
    By default, bzr will try to merge in all new work from the other
3698
 
    branch, automatically determining an appropriate base.  If this
3699
 
    fails, you may need to give an explicit base.
 
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.
3700
3852
 
3701
3853
    Merge will do its best to combine the changes in two branches, but there
3702
3854
    are some kinds of problems only a human can fix.  When it encounters those,
3726
3878
    you to apply each diff hunk and file change, similar to "shelve".
3727
3879
 
3728
3880
    :Examples:
3729
 
        To merge the latest revision from bzr.dev::
 
3881
        To merge all new revisions from bzr.dev::
3730
3882
 
3731
3883
            bzr merge ../bzr.dev
3732
3884
 
3847
3999
            merger.other_rev_id is not None):
3848
4000
            note('Nothing to do.')
3849
4001
            return 0
3850
 
        if pull:
 
4002
        if pull and not preview:
3851
4003
            if merger.interesting_files is not None:
3852
4004
                raise errors.BzrCommandError('Cannot pull individual files')
3853
4005
            if (merger.base_rev_id == tree.last_revision()):
3966
4118
        if ((remember or tree.branch.get_submit_branch() is None) and
3967
4119
             user_location is not None):
3968
4120
            tree.branch.set_submit_branch(other_branch.base)
3969
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
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)
3970
4124
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3971
4125
            other_revision_id, base_revision_id, other_branch, base_branch)
3972
4126
        if other_path != '':
4140
4294
    last committed revision is used.
4141
4295
 
4142
4296
    To remove only some changes, without reverting to a prior version, use
4143
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4144
 
    changes introduced by -2, without affecting the changes introduced by -1.
4145
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
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.
4146
4301
 
4147
4302
    By default, any files that have been manually changed will be backed up
4148
4303
    first.  (Files changed only by merge are not backed up.)  Backup files have
4178
4333
    target branches.
4179
4334
    """
4180
4335
 
4181
 
    _see_also = ['cat', 'export']
 
4336
    _see_also = ['cat', 'export', 'merge', 'shelve']
4182
4337
    takes_options = [
4183
4338
        'revision',
4184
4339
        Option('no-backup', "Do not save backups of reverted files."),
4477
4632
 
4478
4633
    @display_command
4479
4634
    def run(self, verbose=False):
4480
 
        import bzrlib.plugin
4481
 
        from inspect import getdoc
4482
 
        result = []
4483
 
        for name, plugin in bzrlib.plugin.plugins().items():
4484
 
            version = plugin.__version__
4485
 
            if version == 'unknown':
4486
 
                version = ''
4487
 
            name_ver = '%s %s' % (name, version)
4488
 
            d = getdoc(plugin.module)
4489
 
            if d:
4490
 
                doc = d.split('\n')[0]
4491
 
            else:
4492
 
                doc = '(no description)'
4493
 
            result.append((name_ver, doc, plugin.path()))
4494
 
        for name_ver, doc, path in sorted(result):
4495
 
            self.outf.write("%s\n" % name_ver)
4496
 
            self.outf.write("   %s\n" % doc)
4497
 
            if verbose:
4498
 
                self.outf.write("   %s\n" % path)
4499
 
            self.outf.write("\n")
 
4635
        from bzrlib import plugin
 
4636
        self.outf.writelines(
 
4637
            plugin.describe_plugins(show_paths=verbose))
4500
4638
 
4501
4639
 
4502
4640
class cmd_testament(Command):
4555
4693
    @display_command
4556
4694
    def run(self, filename, all=False, long=False, revision=None,
4557
4695
            show_ids=False, directory=None):
4558
 
        from bzrlib.annotate import annotate_file, annotate_file_tree
 
4696
        from bzrlib.annotate import (
 
4697
            annotate_file_tree,
 
4698
            )
4559
4699
        wt, branch, relpath = \
4560
4700
            _open_directory_or_containing_tree_or_branch(filename, directory)
4561
4701
        if wt is not None:
4564
4704
            self.add_cleanup(branch.lock_read().unlock)
4565
4705
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4566
4706
        self.add_cleanup(tree.lock_read().unlock)
4567
 
        if wt is not None:
 
4707
        if wt is not None and revision is None:
4568
4708
            file_id = wt.path2id(relpath)
4569
4709
        else:
4570
4710
            file_id = tree.path2id(relpath)
4571
4711
        if file_id is None:
4572
4712
            raise errors.NotVersionedError(filename)
4573
 
        file_version = tree.inventory[file_id].revision
4574
4713
        if wt is not None and revision is None:
4575
4714
            # If there is a tree and we're not annotating historical
4576
4715
            # versions, annotate the working tree's content.
4577
4716
            annotate_file_tree(wt, file_id, self.outf, long, all,
4578
4717
                show_ids=show_ids)
4579
4718
        else:
4580
 
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4581
 
                          show_ids=show_ids)
 
4719
            annotate_file_tree(tree, file_id, self.outf, long, all,
 
4720
                show_ids=show_ids, branch=branch)
4582
4721
 
4583
4722
 
4584
4723
class cmd_re_sign(Command):
4798
4937
            self.outf.write('The above revision(s) will be removed.\n')
4799
4938
 
4800
4939
        if not force:
4801
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4802
 
                self.outf.write('Canceled')
 
4940
            if not ui.ui_factory.confirm_action(
 
4941
                    'Uncommit these revisions',
 
4942
                    'bzrlib.builtins.uncommit',
 
4943
                    {}):
 
4944
                self.outf.write('Canceled\n')
4803
4945
                return 0
4804
4946
 
4805
4947
        mutter('Uncommitting from {%s} to {%s}',
4832
4974
    takes_options = [
4833
4975
        Option('config',
4834
4976
               help='LOCATION is the directory where the config lock is.'),
 
4977
        Option('force',
 
4978
            help='Do not ask for confirmation before breaking the lock.'),
4835
4979
        ]
4836
4980
 
4837
 
    def run(self, location=None, config=False):
 
4981
    def run(self, location=None, config=False, force=False):
4838
4982
        if location is None:
4839
4983
            location = u'.'
 
4984
        if force:
 
4985
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
4986
                None,
 
4987
                {'bzrlib.lockdir.break': True})
4840
4988
        if config:
4841
4989
            conf = _mod_config.LockableConfig(file_name=location)
4842
4990
            conf.break_lock()
4936
5084
    not part of it.  (Such trees can be produced by "bzr split", but also by
4937
5085
    running "bzr branch" with the target inside a tree.)
4938
5086
 
4939
 
    The result is a combined tree, with the subtree no longer an independant
 
5087
    The result is a combined tree, with the subtree no longer an independent
4940
5088
    part.  This is marked as a merge of the subtree into the containing tree,
4941
5089
    and all history is preserved.
4942
5090
    """
5338
5486
            if tag_name is None:
5339
5487
                raise errors.BzrCommandError("No tag specified to delete.")
5340
5488
            branch.tags.delete_tag(tag_name)
5341
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5489
            note('Deleted tag %s.' % tag_name)
5342
5490
        else:
5343
5491
            if revision:
5344
5492
                if len(revision) != 1:
5356
5504
            if (not force) and branch.tags.has_tag(tag_name):
5357
5505
                raise errors.TagAlreadyExists(tag_name)
5358
5506
            branch.tags.set_tag(tag_name, revision_id)
5359
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5507
            note('Created tag %s.' % tag_name)
5360
5508
 
5361
5509
 
5362
5510
class cmd_tags(Command):
5369
5517
    takes_options = [
5370
5518
        custom_help('directory',
5371
5519
            help='Branch whose tags should be displayed.'),
5372
 
        RegistryOption.from_kwargs('sort',
 
5520
        RegistryOption('sort',
5373
5521
            'Sort tags by different criteria.', title='Sorting',
5374
 
            alpha='Sort tags lexicographically (default).',
5375
 
            time='Sort tags chronologically.',
 
5522
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5376
5523
            ),
5377
5524
        'show-ids',
5378
5525
        'revision',
5379
5526
    ]
5380
5527
 
5381
5528
    @display_command
5382
 
    def run(self,
5383
 
            directory='.',
5384
 
            sort='alpha',
5385
 
            show_ids=False,
5386
 
            revision=None,
5387
 
            ):
 
5529
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
5530
        from bzrlib.tag import tag_sort_methods
5388
5531
        branch, relpath = Branch.open_containing(directory)
5389
5532
 
5390
5533
        tags = branch.tags.get_tag_dict().items()
5399
5542
            # only show revisions between revid1 and revid2 (inclusive)
5400
5543
            tags = [(tag, revid) for tag, revid in tags if
5401
5544
                graph.is_between(revid, revid1, revid2)]
5402
 
        if sort == 'alpha':
5403
 
            tags.sort()
5404
 
        elif sort == 'time':
5405
 
            timestamps = {}
5406
 
            for tag, revid in tags:
5407
 
                try:
5408
 
                    revobj = branch.repository.get_revision(revid)
5409
 
                except errors.NoSuchRevision:
5410
 
                    timestamp = sys.maxint # place them at the end
5411
 
                else:
5412
 
                    timestamp = revobj.timestamp
5413
 
                timestamps[revid] = timestamp
5414
 
            tags.sort(key=lambda x: timestamps[x[1]])
 
5545
        if sort is None:
 
5546
            sort = tag_sort_methods.get()
 
5547
        sort(branch, tags)
5415
5548
        if not show_ids:
5416
5549
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5417
5550
            for index, (tag, revid) in enumerate(tags):
5419
5552
                    revno = branch.revision_id_to_dotted_revno(revid)
5420
5553
                    if isinstance(revno, tuple):
5421
5554
                        revno = '.'.join(map(str, revno))
5422
 
                except errors.NoSuchRevision:
 
5555
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
5423
5556
                    # Bad tag data/merges can lead to tagged revisions
5424
5557
                    # which are not in this branch. Fail gracefully ...
5425
5558
                    revno = '?'
5815
5948
            location = "."
5816
5949
        branch = Branch.open_containing(location)[0]
5817
5950
        branch.bzrdir.destroy_branch()
5818
 
        
 
5951
 
5819
5952
 
5820
5953
class cmd_shelve(Command):
5821
5954
    __doc__ = """Temporarily set aside some changes from the current tree.
5840
5973
 
5841
5974
    You can put multiple items on the shelf, and by default, 'unshelve' will
5842
5975
    restore the most recently shelved changes.
 
5976
 
 
5977
    For complicated changes, it is possible to edit the changes in a separate
 
5978
    editor program to decide what the file remaining in the working copy
 
5979
    should look like.  To do this, add the configuration option
 
5980
 
 
5981
        change_editor = PROGRAM @new_path @old_path
 
5982
 
 
5983
    where @new_path is replaced with the path of the new version of the 
 
5984
    file and @old_path is replaced with the path of the old version of 
 
5985
    the file.  The PROGRAM should save the new file with the desired 
 
5986
    contents of the file in the working tree.
 
5987
        
5843
5988
    """
5844
5989
 
5845
5990
    takes_args = ['file*']
5857
6002
        Option('destroy',
5858
6003
               help='Destroy removed changes instead of shelving them.'),
5859
6004
    ]
5860
 
    _see_also = ['unshelve']
 
6005
    _see_also = ['unshelve', 'configuration']
5861
6006
 
5862
6007
    def run(self, revision=None, all=False, file_list=None, message=None,
5863
 
            writer=None, list=False, destroy=False, directory=u'.'):
 
6008
            writer=None, list=False, destroy=False, directory=None):
5864
6009
        if list:
5865
 
            return self.run_for_list()
 
6010
            return self.run_for_list(directory=directory)
5866
6011
        from bzrlib.shelf_ui import Shelver
5867
6012
        if writer is None:
5868
6013
            writer = bzrlib.option.diff_writer_registry.get()
5876
6021
        except errors.UserAbort:
5877
6022
            return 0
5878
6023
 
5879
 
    def run_for_list(self):
5880
 
        tree = WorkingTree.open_containing('.')[0]
 
6024
    def run_for_list(self, directory=None):
 
6025
        if directory is None:
 
6026
            directory = u'.'
 
6027
        tree = WorkingTree.open_containing(directory)[0]
5881
6028
        self.add_cleanup(tree.lock_read().unlock)
5882
6029
        manager = tree.get_shelf_manager()
5883
6030
        shelves = manager.active_shelves()
5942
6089
    """
5943
6090
    takes_options = ['directory',
5944
6091
                     Option('ignored', help='Delete all ignored files.'),
5945
 
                     Option('detritus', help='Delete conflict files, merge'
 
6092
                     Option('detritus', help='Delete conflict files, merge and revert'
5946
6093
                            ' backups, and failed selftest dirs.'),
5947
6094
                     Option('unknown',
5948
6095
                            help='Delete files unknown to bzr (default).'),
6012
6159
    # be only called once.
6013
6160
    for (name, aliases, module_name) in [
6014
6161
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6162
        ('cmd_config', [], 'bzrlib.config'),
6015
6163
        ('cmd_dpush', [], 'bzrlib.foreign'),
6016
6164
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6017
6165
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6018
6166
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6019
6167
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6168
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6020
6169
        ]:
6021
6170
        builtin_command_registry.register_lazy(name, aliases, module_name)