~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: John Arbash Meinel
  • Date: 2006-06-26 16:31:49 UTC
  • mfrom: (1813 +trunk)
  • mto: (1711.7.2 win32)
  • mto: This revision was merged to the branch mainline in revision 1822.
  • Revision ID: john@arbash-meinel.com-20060626163149-2213f2f2d895829d
[merge] bzr.dev 1813

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
import codecs
21
21
import errno
22
22
import os
23
 
from shutil import rmtree
24
23
import sys
25
24
 
26
25
import bzrlib
27
 
import bzrlib.branch
28
 
from bzrlib.branch import Branch
29
 
import bzrlib.bzrdir as bzrdir
 
26
from bzrlib.branch import Branch, BranchReferenceFormat
 
27
from bzrlib import (bundle, branch, bzrdir, errors, osutils, ui, config,
 
28
    repository, log)
30
29
from bzrlib.bundle import read_bundle_from_url
31
 
from bzrlib.bundle.read_bundle import BundleReader
32
30
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
33
31
from bzrlib.commands import Command, display_command
34
 
import bzrlib.errors as errors
35
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 
36
33
                           NotBranchError, DivergedBranches, NotConflicted,
37
34
                           NoSuchFile, NoWorkingTree, FileInWrongBranch,
38
35
                           NotVersionedError, NotABundle)
39
 
from bzrlib.log import show_one_log
40
36
from bzrlib.merge import Merge3Merger
41
37
from bzrlib.option import Option
42
 
import bzrlib.osutils
43
38
from bzrlib.progress import DummyProgress, ProgressPhase
44
39
from bzrlib.revision import common_ancestor
45
40
from bzrlib.revisionspec import RevisionSpec
46
 
import bzrlib.trace
47
 
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
 
41
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
48
42
from bzrlib.transport.local import LocalTransport
49
 
import bzrlib.ui
50
43
import bzrlib.urlutils as urlutils
51
44
from bzrlib.workingtree import WorkingTree
52
45
 
95
88
        return bzrdir.BzrDirMetaFormat1()
96
89
    if typestring == "metaweave":
97
90
        format = bzrdir.BzrDirMetaFormat1()
98
 
        format.repository_format = bzrlib.repository.RepositoryFormat7()
 
91
        format.repository_format = repository.RepositoryFormat7()
99
92
        return format
100
93
    if typestring == "knit":
101
94
        format = bzrdir.BzrDirMetaFormat1()
102
 
        format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
 
95
        format.repository_format = repository.RepositoryFormatKnit1()
103
96
        return format
104
97
    msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
105
98
          "metaweave and weave" % typestring
416
409
 
417
410
    If there is no default location set, the first pull will set it.  After
418
411
    that, you can omit the location to use the default.  To change the
419
 
    default, use --remember.
 
412
    default, use --remember. The value will only be saved if the remote
 
413
    location can be accessed.
420
414
    """
421
415
 
422
416
    takes_options = ['remember', 'overwrite', 'revision', 'verbose']
435
429
        reader = None
436
430
        if location is not None:
437
431
            try:
438
 
                reader = read_bundle_from_url(location)
 
432
                reader = bundle.read_bundle_from_url(location)
439
433
            except NotABundle:
440
434
                pass # Continue on considering this url a Branch
441
435
 
462
456
        rev_id = None
463
457
        if revision is None:
464
458
            if reader is not None:
465
 
                rev_id = reader.info.target
 
459
                rev_id = reader.target
466
460
        elif len(revision) == 1:
467
461
            rev_id = revision[0].in_history(branch_from).rev_id
468
462
        else:
506
500
 
507
501
    If there is no default push location set, the first push will set it.
508
502
    After that, you can omit the location to use the default.  To change the
509
 
    default, use --remember.
 
503
    default, use --remember. The value will only be saved if the remote
 
504
    location can be accessed.
510
505
    """
511
506
 
512
507
    takes_options = ['remember', 'overwrite', 'verbose',
530
525
            else:
531
526
                display_url = urlutils.unescape_for_display(stored_loc,
532
527
                        self.outf.encoding)
533
 
                self.outf.write("Using saved location: %s" % display_url)
 
528
                self.outf.write("Using saved location: %s\n" % display_url)
534
529
                location = stored_loc
535
530
 
536
531
        transport = get_transport(location)
537
532
        location_url = transport.base
538
 
        if br_from.get_push_location() is None or remember:
539
 
            br_from.set_push_location(location_url)
540
533
 
541
534
        old_rh = []
542
535
        try:
543
 
            dir_to = bzrlib.bzrdir.BzrDir.open(location_url)
 
536
            dir_to = bzrdir.BzrDir.open(location_url)
544
537
            br_to = dir_to.open_branch()
545
538
        except NotBranchError:
546
539
            # create a branch.
572
565
                revision_id=br_from.last_revision())
573
566
            br_to = dir_to.open_branch()
574
567
            count = len(br_to.revision_history())
 
568
            # We successfully created the target, remember it
 
569
            if br_from.get_push_location() is None or remember:
 
570
                br_from.set_push_location(br_to.base)
575
571
        else:
 
572
            # We were able to connect to the remote location, so remember it
 
573
            # we don't need to successfully push because of possible divergence.
 
574
            if br_from.get_push_location() is None or remember:
 
575
                br_from.set_push_location(br_to.base)
576
576
            old_rh = br_to.revision_history()
577
577
            try:
578
578
                try:
618
618
 
619
619
    def run(self, from_location, to_location=None, revision=None, basis=None):
620
620
        from bzrlib.transport import get_transport
621
 
        from bzrlib.osutils import rmtree
622
621
        if revision is None:
623
622
            revision = [None]
624
623
        elif len(revision) > 1:
654
653
            to_transport = get_transport(to_location)
655
654
            try:
656
655
                to_transport.mkdir('.')
657
 
            except bzrlib.errors.FileExists:
 
656
            except errors.FileExists:
658
657
                raise BzrCommandError('Target directory "%s" already'
659
658
                                      ' exists.' % to_location)
660
 
            except bzrlib.errors.NoSuchFile:
 
659
            except errors.NoSuchFile:
661
660
                raise BzrCommandError('Parent of "%s" does not exist.' %
662
661
                                      to_location)
663
662
            try:
665
664
                dir = br_from.bzrdir.sprout(to_transport.base,
666
665
                        revision_id, basis_dir)
667
666
                branch = dir.open_branch()
668
 
            except bzrlib.errors.NoSuchRevision:
 
667
            except errors.NoSuchRevision:
669
668
                to_transport.delete_tree('.')
670
669
                msg = "The branch %s has no revision %s." % (from_location, revision[0])
671
670
                raise BzrCommandError(msg)
672
 
            except bzrlib.errors.UnlistableBranch:
673
 
                rmtree(to_location)
 
671
            except errors.UnlistableBranch:
 
672
                osutils.rmtree(to_location)
674
673
                msg = "The branch %s cannot be used as a --basis" % (basis,)
675
674
                raise BzrCommandError(msg)
676
675
            if name:
719
718
            raise BzrCommandError(
720
719
                'bzr checkout --revision takes exactly 1 revision value')
721
720
        if branch_location is None:
722
 
            branch_location = bzrlib.osutils.getcwd()
 
721
            branch_location = osutils.getcwd()
723
722
            to_location = branch_location
724
723
        source = Branch.open(branch_location)
725
724
        if len(revision) == 1 and revision[0] is not None:
731
730
        # if the source and to_location are the same, 
732
731
        # and there is no working tree,
733
732
        # then reconstitute a branch
734
 
        if (bzrlib.osutils.abspath(to_location) == 
735
 
            bzrlib.osutils.abspath(branch_location)):
 
733
        if (osutils.abspath(to_location) == 
 
734
            osutils.abspath(branch_location)):
736
735
            try:
737
736
                source.bzrdir.open_workingtree()
738
737
            except errors.NoWorkingTree:
749
748
                                      to_location)
750
749
            else:
751
750
                raise
752
 
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
753
 
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
 
751
        old_format = bzrdir.BzrDirFormat.get_default_format()
 
752
        bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
754
753
        try:
755
754
            if lightweight:
756
755
                checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
757
 
                bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
756
                branch.BranchReferenceFormat().initialize(checkout, source)
758
757
            else:
759
 
                checkout_branch =  bzrlib.bzrdir.BzrDir.create_branch_convenience(
 
758
                checkout_branch =  bzrdir.BzrDir.create_branch_convenience(
760
759
                    to_location, force_new_tree=False)
761
760
                checkout = checkout_branch.bzrdir
762
761
                checkout_branch.bind(source)
765
764
                    checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
766
765
            checkout.create_workingtree(revision_id)
767
766
        finally:
768
 
            bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
 
767
            bzrdir.BzrDirFormat.set_default_format(old_format)
769
768
 
770
769
 
771
770
class cmd_renames(Command):
778
777
 
779
778
    @display_command
780
779
    def run(self, dir=u'.'):
 
780
        from bzrlib.tree import find_renames
781
781
        tree = WorkingTree.open_containing(dir)[0]
782
782
        old_inv = tree.basis_tree().inventory
783
783
        new_inv = tree.read_working_inventory()
784
 
 
785
 
        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
 
784
        renames = list(find_renames(old_inv, new_inv))
786
785
        renames.sort()
787
786
        for old_name, new_name in renames:
788
787
            self.outf.write("%s => %s\n" % (old_name, new_name))
936
935
 
937
936
    def run(self, branch="."):
938
937
        from bzrlib.reconcile import reconcile
939
 
        dir = bzrlib.bzrdir.BzrDir.open(branch)
 
938
        dir = bzrdir.BzrDir.open(branch)
940
939
        reconcile(dir)
941
940
 
942
941
 
943
942
class cmd_revision_history(Command):
944
 
    """Display list of revision ids on this branch."""
 
943
    """Display the list of revision ids on a branch."""
 
944
    takes_args = ['location?']
 
945
 
945
946
    hidden = True
946
947
 
947
948
    @display_command
948
 
    def run(self):
949
 
        branch = WorkingTree.open_containing(u'.')[0].branch
950
 
        for patchid in branch.revision_history():
951
 
            self.outf.write(patchid)
 
949
    def run(self, location="."):
 
950
        branch = Branch.open_containing(location)[0]
 
951
        for revid in branch.revision_history():
 
952
            self.outf.write(revid)
952
953
            self.outf.write('\n')
953
954
 
954
955
 
955
956
class cmd_ancestry(Command):
956
957
    """List all revisions merged into this branch."""
 
958
    takes_args = ['location?']
 
959
 
957
960
    hidden = True
958
961
 
959
962
    @display_command
960
 
    def run(self):
961
 
        tree = WorkingTree.open_containing(u'.')[0]
962
 
        b = tree.branch
963
 
        # FIXME. should be tree.last_revision
964
 
        revision_ids = b.repository.get_ancestry(b.last_revision())
 
963
    def run(self, location="."):
 
964
        try:
 
965
            wt = WorkingTree.open_containing(location)[0]
 
966
        except errors.NoWorkingTree:
 
967
            b = Branch.open(location)
 
968
            last_revision = b.last_revision()
 
969
        else:
 
970
            b = wt.branch
 
971
            last_revision = wt.last_revision()
 
972
 
 
973
        revision_ids = b.repository.get_ancestry(last_revision)
965
974
        assert revision_ids[0] == None
966
975
        revision_ids.pop(0)
967
976
        for revision_id in revision_ids:
999
1008
                            type=get_format_type),
1000
1009
                     ]
1001
1010
    def run(self, location=None, format=None):
1002
 
        from bzrlib.branch import Branch
1003
1011
        if format is None:
1004
1012
            format = get_format_type('default')
1005
1013
        if location is None:
1204
1212
            if file_id in basis_inv:
1205
1213
                continue
1206
1214
            path = inv.id2path(file_id)
1207
 
            if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
 
1215
            if not os.access(osutils.abspath(path), os.F_OK):
1208
1216
                continue
1209
1217
            self.outf.write(path + '\n')
1210
1218
 
1319
1327
            (rev2, rev1) = (rev1, rev2)
1320
1328
 
1321
1329
        if (log_format == None):
1322
 
            default = bzrlib.config.BranchConfig(b).log_format()
1323
 
            log_format = get_log_format(long=long, short=short, line=line, default=default)
 
1330
            default = b.get_config().log_format()
 
1331
            log_format = get_log_format(long=long, short=short, line=line, 
 
1332
                                        default=default)
1324
1333
        lf = log_formatter(log_format,
1325
1334
                           show_ids=show_ids,
1326
1335
                           to_file=self.outf,
1362
1371
        b = tree.branch
1363
1372
        inv = tree.read_working_inventory()
1364
1373
        file_id = inv.path2id(relpath)
1365
 
        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
 
1374
        for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1366
1375
            self.outf.write("%6d %s\n" % (revno, what))
1367
1376
 
1368
1377
 
1424
1433
    """List unknown files."""
1425
1434
    @display_command
1426
1435
    def run(self):
1427
 
        from bzrlib.osutils import quotefn
1428
1436
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
1429
 
            self.outf.write(quotefn(f) + '\n')
 
1437
            self.outf.write(osutils.quotefn(f) + '\n')
1430
1438
 
1431
1439
 
1432
1440
class cmd_ignore(Command):
1596
1604
    hidden = True    
1597
1605
    @display_command
1598
1606
    def run(self):
1599
 
        print bzrlib.osutils.local_time_offset()
 
1607
        print osutils.local_time_offset()
1600
1608
 
1601
1609
 
1602
1610
 
1680
1688
            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1681
1689
 
1682
1690
        if message == "":
1683
 
                raise BzrCommandError("empty commit message specified")
 
1691
            raise BzrCommandError("empty commit message specified")
1684
1692
        
1685
1693
        if verbose:
1686
1694
            reporter = ReportCommitToLog()
1778
1786
    @display_command
1779
1787
    def run(self, email=False):
1780
1788
        try:
1781
 
            b = WorkingTree.open_containing(u'.')[0].branch
1782
 
            config = bzrlib.config.BranchConfig(b)
 
1789
            c = WorkingTree.open_containing(u'.')[0].branch.get_config()
1783
1790
        except NotBranchError:
1784
 
            config = bzrlib.config.GlobalConfig()
1785
 
        
 
1791
            c = config.GlobalConfig()
1786
1792
        if email:
1787
 
            print config.user_email()
 
1793
            print c.user_email()
1788
1794
        else:
1789
 
            print config.username()
 
1795
            print c.username()
1790
1796
 
1791
1797
 
1792
1798
class cmd_nick(Command):
1872
1878
        # we don't want progress meters from the tests to go to the
1873
1879
        # real output; and we don't want log messages cluttering up
1874
1880
        # the real logs.
1875
 
        save_ui = bzrlib.ui.ui_factory
1876
 
        print '%10s: %s' % ('bzr', bzrlib.osutils.realpath(sys.argv[0]))
 
1881
        save_ui = ui.ui_factory
 
1882
        print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1877
1883
        print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1878
1884
        print
1879
 
        bzrlib.trace.info('running tests...')
 
1885
        info('running tests...')
1880
1886
        try:
1881
 
            bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
1887
            ui.ui_factory = ui.SilentUIFactory()
1882
1888
            if testspecs_list is not None:
1883
1889
                pattern = '|'.join(testspecs_list)
1884
1890
            else:
1899
1905
                              test_suite_factory=test_suite_factory,
1900
1906
                              lsprof_timed=lsprof_timed)
1901
1907
            if result:
1902
 
                bzrlib.trace.info('tests passed')
 
1908
                info('tests passed')
1903
1909
            else:
1904
 
                bzrlib.trace.info('tests failed')
 
1910
                info('tests failed')
1905
1911
            return int(not result)
1906
1912
        finally:
1907
 
            bzrlib.ui.ui_factory = save_ui
 
1913
            ui.ui_factory = save_ui
1908
1914
 
1909
1915
 
1910
1916
def _get_bzr_branch():
1911
1917
    """If bzr is run from a branch, return Branch or None"""
1912
 
    import bzrlib.errors
1913
 
    from bzrlib.branch import Branch
1914
 
    from bzrlib.osutils import abspath
1915
1918
    from os.path import dirname
1916
1919
    
1917
1920
    try:
1918
 
        branch = Branch.open(dirname(abspath(dirname(__file__))))
 
1921
        branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1919
1922
        return branch
1920
 
    except bzrlib.errors.BzrError:
 
1923
    except errors.BzrError:
1921
1924
        return None
1922
1925
    
1923
1926
 
1924
1927
def show_version():
 
1928
    import bzrlib
1925
1929
    print "bzr (bazaar-ng) %s" % bzrlib.__version__
1926
1930
    # is bzrlib itself in a branch?
1927
1931
    branch = _get_bzr_branch()
1993
1997
        base_rev_id = common_ancestor(last1, last2, source)
1994
1998
 
1995
1999
        print 'merge base is revision %s' % base_rev_id
1996
 
        
1997
 
        return
1998
 
 
1999
 
        if base_revno is None:
2000
 
            raise bzrlib.errors.UnrelatedBranches()
2001
 
 
2002
 
        print ' r%-6d in %s' % (base_revno, branch)
2003
 
 
2004
 
        other_revno = branch2.revision_id_to_revno(base_revid)
2005
 
        
2006
 
        print ' r%-6d in %s' % (other_revno, other)
2007
 
 
2008
2000
 
2009
2001
 
2010
2002
class cmd_merge(Command):
2011
2003
    """Perform a three-way merge.
2012
2004
    
2013
 
    The branch is the branch you will merge from.  By default, it will
2014
 
    merge the latest revision.  If you specify a revision, that
2015
 
    revision will be merged.  If you specify two revisions, the first
2016
 
    will be used as a BASE, and the second one as OTHER.  Revision
2017
 
    numbers are always relative to the specified branch.
 
2005
    The branch is the branch you will merge from.  By default, it will merge
 
2006
    the latest revision.  If you specify a revision, that revision will be
 
2007
    merged.  If you specify two revisions, the first will be used as a BASE,
 
2008
    and the second one as OTHER.  Revision numbers are always relative to the
 
2009
    specified branch.
2018
2010
 
2019
2011
    By default, bzr will try to merge in all new work from the other
2020
2012
    branch, automatically determining an appropriate base.  If this
2029
2021
 
2030
2022
    If there is no default branch set, the first merge will set it. After
2031
2023
    that, you can omit the branch to use the default.  To change the
2032
 
    default, use --remember.
 
2024
    default, use --remember. The value will only be saved if the remote
 
2025
    location can be accessed.
2033
2026
 
2034
2027
    Examples:
2035
2028
 
2066
2059
 
2067
2060
        if branch is not None:
2068
2061
            try:
2069
 
                reader = read_bundle_from_url(branch)
 
2062
                reader = bundle.read_bundle_from_url(branch)
2070
2063
            except NotABundle:
2071
2064
                pass # Continue on considering this url a Branch
2072
2065
            else:
2106
2099
            interesting_files = [path]
2107
2100
        else:
2108
2101
            interesting_files = None
2109
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2102
        pb = ui.ui_factory.nested_progress_bar()
2110
2103
        try:
2111
2104
            try:
2112
2105
                conflict_count = merge(other, base, check_clean=(not force),
2120
2113
                return 1
2121
2114
            else:
2122
2115
                return 0
2123
 
        except bzrlib.errors.AmbiguousBase, e:
 
2116
        except errors.AmbiguousBase, e:
2124
2117
            m = ("sorry, bzr can't determine the right merge base yet\n"
2125
2118
                 "candidates are:\n  "
2126
2119
                 + "\n  ".join(e.bases)
2259
2252
            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
2260
2253
        else:
2261
2254
            rev_id = revision[0].in_history(tree.branch).rev_id
2262
 
        pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
2255
        pb = ui.ui_factory.nested_progress_bar()
2263
2256
        try:
2264
2257
            tree.revert(file_list, 
2265
2258
                        tree.branch.repository.revision_tree(rev_id),
2313
2306
    takes_args = ['from_branch', 'to_branch']
2314
2307
    def run(self, from_branch, to_branch):
2315
2308
        from bzrlib.fetch import Fetcher
2316
 
        from bzrlib.branch import Branch
2317
2309
        from_b = Branch.open(from_branch)
2318
2310
        to_b = Branch.open(to_branch)
2319
2311
        Fetcher(to_b, from_b)
2342
2334
            show_ids=False, verbose=False):
2343
2335
        from bzrlib.missing import find_unmerged, iter_log_data
2344
2336
        from bzrlib.log import log_formatter
2345
 
        local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
 
2337
        local_branch = Branch.open_containing(u".")[0]
2346
2338
        parent = local_branch.get_parent()
2347
2339
        if other_branch is None:
2348
2340
            other_branch = parent
2349
2341
            if other_branch is None:
2350
2342
                raise BzrCommandError("No missing location known or specified.")
2351
2343
            print "Using last location: " + local_branch.get_parent()
2352
 
        remote_branch = bzrlib.branch.Branch.open(other_branch)
 
2344
        remote_branch = Branch.open(other_branch)
2353
2345
        if remote_branch.base == local_branch.base:
2354
2346
            remote_branch = local_branch
2355
2347
        local_branch.lock_read()
2358
2350
            try:
2359
2351
                local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2360
2352
                if (log_format == None):
2361
 
                    default = bzrlib.config.BranchConfig(local_branch).log_format()
2362
 
                    log_format = get_log_format(long=long, short=short, line=line, default=default)
 
2353
                    default = local_branch.get_config().log_format()
 
2354
                    log_format = get_log_format(long=long, short=short, 
 
2355
                                                line=line, default=default)
2363
2356
                lf = log_formatter(log_format, sys.stdout,
2364
2357
                                   show_ids=show_ids,
2365
2358
                                   show_timezone='original')
2424
2417
class cmd_testament(Command):
2425
2418
    """Show testament (signing-form) of a revision."""
2426
2419
    takes_options = ['revision', 'long', 
2427
 
                     Option('strict', help='Produce a strict testament')]
 
2420
                     Option('strict', help='Produce a strict-format'
 
2421
                            ' testament')]
2428
2422
    takes_args = ['branch?']
2429
2423
    @display_command
2430
2424
    def run(self, branch=u'.', revision=None, long=False, strict=False):
2498
2492
    takes_options = ['revision']
2499
2493
    
2500
2494
    def run(self, revision_id_list=None, revision=None):
2501
 
        import bzrlib.config as config
2502
2495
        import bzrlib.gpg as gpg
2503
2496
        if revision_id_list is not None and revision is not None:
2504
2497
            raise BzrCommandError('You can only supply one of revision_id or --revision')
2505
2498
        if revision_id_list is None and revision is None:
2506
2499
            raise BzrCommandError('You must supply either --revision or a revision_id')
2507
2500
        b = WorkingTree.open_containing(u'.')[0].branch
2508
 
        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
 
2501
        gpg_strategy = gpg.GPGStrategy(b.get_config())
2509
2502
        if revision_id_list is not None:
2510
2503
            for revision_id in revision_id_list:
2511
2504
                b.repository.sign_revision(revision_id, gpg_strategy)
2566
2559
            raise BzrCommandError('Local branch is not bound')
2567
2560
 
2568
2561
 
2569
 
class cmd_uncommit(bzrlib.commands.Command):
 
2562
class cmd_uncommit(Command):
2570
2563
    """Remove the last committed revision.
2571
2564
 
2572
2565
    --verbose will print out what is being removed.
2590
2583
    def run(self, location=None, 
2591
2584
            dry_run=False, verbose=False,
2592
2585
            revision=None, force=False):
2593
 
        from bzrlib.branch import Branch
2594
2586
        from bzrlib.log import log_formatter
2595
2587
        import sys
2596
2588
        from bzrlib.uncommit import uncommit