← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Vincent Ladeuil
  • Date: 2012-03-09 16:48:55 UTC
  • mto: (6437.23.24 2.5)
  • mto: This revision was merged to the branch mainline in revision 6499.
  • Revision ID: v.ladeuil+lp@free.fr-20120309164855-htdn25hp7x65mmir
https://launchpad.net/bugs/940164
Rely on sphinx for texinfo doc generation

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
1
 
# Copyright (C) 2005-2012 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
86
86
def _get_branch_location(control_dir, possible_transports=None):
87
87
    """Return location of branch for this control dir."""
88
88
    try:
89
 
        target = control_dir.get_branch_reference()
 
89
        this_branch = control_dir.open_branch(
 
90
            possible_transports=possible_transports)
 
91
        # This may be a heavy checkout, where we want the master branch
 
92
        master_location = this_branch.get_bound_location()
 
93
        if master_location is not None:
 
94
            return master_location
 
95
        # If not, use a local sibling
 
96
        return this_branch.base
90
97
    except errors.NotBranchError:
91
 
        return control_dir.root_transport.base
92
 
    if target is not None:
93
 
        return target
94
 
    this_branch = control_dir.open_branch(
95
 
        possible_transports=possible_transports)
96
 
    # This may be a heavy checkout, where we want the master branch
97
 
    master_location = this_branch.get_bound_location()
98
 
    if master_location is not None:
99
 
        return master_location
100
 
    # If not, use a local sibling
101
 
    return this_branch.base
 
98
        format = control_dir.find_branch_format()
 
99
        if getattr(format, 'get_reference', None) is not None:
 
100
            return format.get_reference(control_dir)
 
101
        else:
 
102
            return control_dir.root_transport.base
102
103
 
103
104
 
104
105
def _is_colocated(control_dir, possible_transports=None):
105
106
    """Check if the branch in control_dir is colocated.
106
107
 
107
108
    :param control_dir: Control directory
108
 
    :return: Tuple with boolean indicating whether the branch is colocated
109
 
        and the full URL to the actual branch
 
109
    :return: Boolean indicating whether 
110
110
    """
111
111
    # This path is meant to be relative to the existing branch
112
112
    this_url = _get_branch_location(control_dir,
132
132
def lookup_new_sibling_branch(control_dir, location, possible_transports=None):
133
133
    """Lookup the location for a new sibling branch.
134
134
 
135
 
    :param control_dir: Control directory to find sibling branches from
 
135
    :param control_dir: Control directory relative to which to look up
 
136
        the name.
136
137
    :param location: Name of the new branch
137
138
    :return: Full location to the new branch
138
139
    """
148
149
    return location
149
150
 
150
151
 
151
 
def open_sibling_branch(control_dir, location, possible_transports=None):
152
 
    """Open a branch, possibly a sibling of another.
153
 
 
 
152
def lookup_sibling_branch(control_dir, location, possible_transports=None):
 
153
    """Lookup sibling branch.
 
154
    
154
155
    :param control_dir: Control directory relative to which to lookup the
155
156
        location.
156
157
    :param location: Location to look up
161
162
        return control_dir.open_branch(location, 
162
163
            possible_transports=possible_transports)
163
164
    except (errors.NotBranchError, errors.NoColocatedBranchSupport):
164
 
        this_url = _get_branch_location(control_dir)
165
 
        return Branch.open(
166
 
            urlutils.join(
167
 
                this_url, '..', urlutils.escape(location)))
168
 
 
169
 
 
170
 
def open_nearby_branch(near=None, location=None, possible_transports=None):
171
 
    """Open a nearby branch.
172
 
 
173
 
    :param near: Optional location of container from which to open branch
174
 
    :param location: Location of the branch
175
 
    :return: Branch instance
176
 
    """
177
 
    if near is None:
178
 
        if location is None:
179
 
            location = "."
180
165
        try:
181
 
            return Branch.open(location,
182
 
                possible_transports=possible_transports)
 
166
            return Branch.open(location)
183
167
        except errors.NotBranchError:
184
 
            near = "."
185
 
    cdir = controldir.ControlDir.open(near,
186
 
        possible_transports=possible_transports)
187
 
    return open_sibling_branch(cdir, location,
188
 
        possible_transports=possible_transports)
189
 
 
190
 
 
191
 
def iter_sibling_branches(control_dir, possible_transports=None):
192
 
    """Iterate over the siblings of a branch.
193
 
 
194
 
    :param control_dir: Control directory for which to look up the siblings
195
 
    :return: Iterator over tuples with branch name and branch object
196
 
    """
197
 
    seen_urls = set()
198
 
    try:
199
 
        reference = control_dir.get_branch_reference()
200
 
    except errors.NotBranchError:
201
 
        # There is no active branch, just return the colocated branches.
202
 
        for name, branch in control_dir.get_branches().iteritems():
203
 
            yield name, branch
204
 
        return
205
 
    if reference is not None:
206
 
        ref_branch = Branch.open(reference,
207
 
            possible_transports=possible_transports)
208
 
    else:
209
 
        ref_branch = None
210
 
    if ref_branch is None or ref_branch.name:
211
 
        if ref_branch is not None:
212
 
            control_dir = ref_branch.bzrdir
213
 
        for name, branch in control_dir.get_branches().iteritems():
214
 
            yield name, branch
215
 
    else:
216
 
        repo = ref_branch.bzrdir.find_repository()
217
 
        for branch in repo.find_branches(using=True):
218
 
            name = urlutils.relative_url(repo.user_url,
219
 
                branch.user_url).rstrip("/")
220
 
            yield name, branch
 
168
            this_url = _get_branch_location(control_dir)
 
169
            return Branch.open(
 
170
                urlutils.join(
 
171
                    this_url, '..', urlutils.escape(location)))
 
172
 
 
173
 
 
174
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
 
175
def tree_files(file_list, default_branch=u'.', canonicalize=True,
 
176
    apply_view=True):
 
177
    return internal_tree_files(file_list, default_branch, canonicalize,
 
178
        apply_view)
221
179
 
222
180
 
223
181
def tree_files_for_add(file_list):
285
243
    return rev_tree
286
244
 
287
245
 
 
246
# XXX: Bad function name; should possibly also be a class method of
 
247
# WorkingTree rather than a function.
 
248
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
 
249
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
 
250
    apply_view=True):
 
251
    """Convert command-line paths to a WorkingTree and relative paths.
 
252
 
 
253
    Deprecated: use WorkingTree.open_containing_paths instead.
 
254
 
 
255
    This is typically used for command-line processors that take one or
 
256
    more filenames, and infer the workingtree that contains them.
 
257
 
 
258
    The filenames given are not required to exist.
 
259
 
 
260
    :param file_list: Filenames to convert.
 
261
 
 
262
    :param default_branch: Fallback tree path to use if file_list is empty or
 
263
        None.
 
264
 
 
265
    :param apply_view: if True and a view is set, apply it or check that
 
266
        specified files are within it
 
267
 
 
268
    :return: workingtree, [relative_paths]
 
269
    """
 
270
    return WorkingTree.open_containing_paths(
 
271
        file_list, default_directory='.',
 
272
        canonicalize=True,
 
273
        apply_view=True)
 
274
 
 
275
 
288
276
def _get_view_info_for_change_reporter(tree):
289
277
    """Get the view information from a tree for change reporting."""
290
278
    view_info = None
368
356
    This will produce the same results as calling 'bzr diff --summarize'.
369
357
    """
370
358
 
371
 
    # TODO: --no-recurse/-N, --recurse options
 
359
    # TODO: --no-recurse, --recurse options
372
360
 
373
361
    takes_args = ['file*']
374
362
    takes_options = ['show-ids', 'revision', 'change', 'verbose',
803
791
    takes_args = ['file*']
804
792
    takes_options = [
805
793
        Option('no-recurse',
806
 
               help="Don't recursively add the contents of directories.",
807
 
               short_name='N'),
 
794
               help="Don't recursively add the contents of directories."),
808
795
        Option('dry-run',
809
796
               help="Show what would be done, but don't actually do anything."),
810
797
        'verbose',
950
937
            tree = work_tree
951
938
            extra_trees = []
952
939
 
953
 
        self.add_cleanup(tree.lock_read().unlock)
954
940
        if file_list is not None:
955
941
            file_ids = tree.paths2ids(file_list, trees=extra_trees,
956
942
                                      require_versioned=True)
957
943
            # find_ids_across_trees may include some paths that don't
958
944
            # exist in 'tree'.
959
 
            entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
 
945
            entries = sorted(
 
946
                (tree.id2path(file_id), tree.inventory[file_id])
 
947
                for file_id in file_ids if tree.has_id(file_id))
960
948
        else:
961
 
            entries = tree.iter_entries_by_dir()
 
949
            entries = tree.inventory.entries()
962
950
 
963
 
        for path, entry in sorted(entries):
 
951
        self.cleanup_now()
 
952
        for path, entry in entries:
964
953
            if kind and kind != entry.kind:
965
954
                continue
966
 
            if path == "":
967
 
                continue
968
955
            if show_ids:
969
956
                self.outf.write('%-50s %s\n' % (path, entry.file_id))
970
957
            else:
1042
1029
                and rel_names[0].lower() == rel_names[1].lower()):
1043
1030
                into_existing = False
1044
1031
            else:
 
1032
                inv = tree.inventory
1045
1033
                # 'fix' the case of a potential 'from'
1046
1034
                from_id = tree.path2id(
1047
1035
                            tree.get_canonical_inventory_path(rel_names[0]))
1048
1036
                if (not osutils.lexists(names_list[0]) and
1049
 
                    from_id and tree.stored_kind(from_id) == "directory"):
 
1037
                    from_id and inv.get_file_kind(from_id) == "directory"):
1050
1038
                    into_existing = False
1051
1039
        # move/rename
1052
1040
        if into_existing:
1153
1141
                 "the master branch."
1154
1142
            ),
1155
1143
        Option('show-base',
1156
 
            help="Show base revision text in conflicts."),
1157
 
        Option('overwrite-tags',
1158
 
            help="Overwrite tags only."),
 
1144
            help="Show base revision text in conflicts.")
1159
1145
        ]
1160
1146
    takes_args = ['location?']
1161
1147
    encoding_type = 'replace'
1163
1149
    def run(self, location=None, remember=None, overwrite=False,
1164
1150
            revision=None, verbose=False,
1165
1151
            directory=None, local=False,
1166
 
            show_base=False, overwrite_tags=False):
1167
 
 
1168
 
        if overwrite:
1169
 
            overwrite = ["history", "tags"]
1170
 
        elif overwrite_tags:
1171
 
            overwrite = ["tags"]
1172
 
        else:
1173
 
            overwrite = []
 
1152
            show_base=False):
1174
1153
        # FIXME: too much stuff is in the command class
1175
1154
        revision_id = None
1176
1155
        mergeable = None
1227
1206
            # Remembers if asked explicitly or no previous location is set
1228
1207
            if (remember
1229
1208
                or (remember is None and branch_to.get_parent() is None)):
1230
 
                # FIXME: This shouldn't be done before the pull
1231
 
                # succeeds... -- vila 2012-01-02
1232
1209
                branch_to.set_parent(branch_from.base)
1233
1210
 
1234
1211
        if revision is not None:
1314
1291
        Option('no-tree',
1315
1292
               help="Don't populate the working tree, even for protocols"
1316
1293
               " that support it."),
1317
 
        Option('overwrite-tags',
1318
 
              help="Overwrite tags only."),
1319
1294
        ]
1320
1295
    takes_args = ['location?']
1321
1296
    encoding_type = 'replace'
1323
1298
    def run(self, location=None, remember=None, overwrite=False,
1324
1299
        create_prefix=False, verbose=False, revision=None,
1325
1300
        use_existing_dir=False, directory=None, stacked_on=None,
1326
 
        stacked=False, strict=None, no_tree=False,
1327
 
        overwrite_tags=False):
 
1301
        stacked=False, strict=None, no_tree=False):
1328
1302
        from bzrlib.push import _show_push_branch
1329
1303
 
1330
 
        if overwrite:
1331
 
            overwrite = ["history", "tags"]
1332
 
        elif overwrite_tags:
1333
 
            overwrite = ["tags"]
1334
 
        else:
1335
 
            overwrite = []
1336
 
 
1337
1304
        if directory is None:
1338
1305
            directory = '.'
1339
1306
        # Get the source branch
1573
1540
                active_branch = dir.open_branch(name="")
1574
1541
            except errors.NotBranchError:
1575
1542
                active_branch = None
 
1543
            branches = dir.get_branches()
1576
1544
            names = {}
1577
 
            for name, branch in iter_sibling_branches(dir):
 
1545
            for name, branch in branches.iteritems():
1578
1546
                if name == "":
1579
1547
                    continue
1580
1548
                active = (active_branch is not None and
1681
1649
    def run(self, dir=u'.'):
1682
1650
        tree = WorkingTree.open_containing(dir)[0]
1683
1651
        self.add_cleanup(tree.lock_read().unlock)
 
1652
        new_inv = tree.inventory
1684
1653
        old_tree = tree.basis_tree()
1685
1654
        self.add_cleanup(old_tree.lock_read().unlock)
 
1655
        old_inv = old_tree.inventory
1686
1656
        renames = []
1687
1657
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1688
1658
        for f, paths, c, v, p, n, k, e in iterator:
1859
1829
 
1860
1830
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
1861
1831
    delete them if they can easily be recovered using revert otherwise they
1862
 
    will be backed up (adding an extension of the form .~#~). If no options or
 
1832
    will be backed up (adding an extention of the form .~#~). If no options or
1863
1833
    parameters are given Bazaar will scan for files that are being tracked by
1864
1834
    Bazaar but missing in your tree and stop tracking them for you.
1865
1835
    """
2073
2043
         RegistryOption('format',
2074
2044
                help='Specify a format for this branch. '
2075
2045
                'See "help formats".',
2076
 
                lazy_registry=('bzrlib.controldir', 'format_registry'),
 
2046
                lazy_registry=('bzrlib.bzrdir', 'format_registry'),
2077
2047
                converter=lambda name: controldir.format_registry.make_bzrdir(name),
2078
2048
                value_switches=True,
2079
2049
                title="Branch format",
2402
2372
        self.add_cleanup(tree.lock_read().unlock)
2403
2373
        old = tree.basis_tree()
2404
2374
        self.add_cleanup(old.lock_read().unlock)
2405
 
        for path, ie in old.iter_entries_by_dir():
 
2375
        for path, ie in old.inventory.iter_entries():
2406
2376
            if not tree.has_id(ie.file_id):
2407
2377
                self.outf.write(path)
2408
2378
                if show_ids:
2446
2416
        self.add_cleanup(wt.lock_read().unlock)
2447
2417
        basis = wt.basis_tree()
2448
2418
        self.add_cleanup(basis.lock_read().unlock)
2449
 
        root_id = wt.get_root_id()
2450
 
        for file_id in wt.all_file_ids():
2451
 
            if basis.has_id(file_id):
2452
 
                continue
2453
 
            if root_id == file_id:
2454
 
                continue
2455
 
            path = wt.id2path(file_id)
 
2419
        basis_inv = basis.inventory
 
2420
        inv = wt.inventory
 
2421
        for file_id in inv:
 
2422
            if basis_inv.has_id(file_id):
 
2423
                continue
 
2424
            if inv.is_root(file_id) and len(basis_inv) == 0:
 
2425
                continue
 
2426
            path = inv.id2path(file_id)
2456
2427
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2457
2428
                continue
2458
2429
            if null:
2820
2791
            self.add_cleanup(b.lock_read().unlock)
2821
2792
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2822
2793
 
2823
 
        if b.get_config_stack().get('validate_signatures_in_log'):
 
2794
        if b.get_config().validate_signatures_in_log():
2824
2795
            signatures = True
2825
2796
 
2826
2797
        if signatures:
3546
3517
            tokens = fixed_bug.split(':')
3547
3518
            if len(tokens) == 1:
3548
3519
                if default_bugtracker is None:
3549
 
                    branch_config = branch.get_config_stack()
3550
 
                    default_bugtracker = branch_config.get(
 
3520
                    branch_config = branch.get_config()
 
3521
                    default_bugtracker = branch_config.get_user_option(
3551
3522
                        "bugtracker")
3552
3523
                if default_bugtracker is None:
3553
3524
                    raise errors.BzrCommandError(gettext(
3892
3863
            if directory is None:
3893
3864
                c = Branch.open_containing(u'.')[0].get_config_stack()
3894
3865
            else:
3895
 
                b = Branch.open(directory)
3896
 
                self.add_cleanup(b.lock_write().unlock)
3897
 
                c = b.get_config_stack()
 
3866
                c = Branch.open(directory).get_config_stack()
3898
3867
        else:
3899
3868
            c = _mod_config.GlobalStack()
3900
3869
        c.set('email', name)
4707
4676
                if tree.kind(file_id) != "directory":
4708
4677
                    continue
4709
4678
 
4710
 
                # FIXME: Support nested trees
4711
 
                for name, ie in tree.root_inventory.iter_entries(file_id):
 
4679
                for name, ie in tree.inventory.iter_entries(file_id):
4712
4680
                    interesting_ids.add(ie.file_id)
4713
4681
            new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4714
4682
        else:
4747
4715
 
4748
4716
 
4749
4717
class cmd_revert(Command):
4750
 
    __doc__ = """\
4751
 
    Set files in the working tree back to the contents of a previous revision.
 
4718
    __doc__ = """Revert files to a previous revision.
4752
4719
 
4753
4720
    Giving a list of files will revert only those files.  Otherwise, all files
4754
4721
    will be reverted.  If the revision is not specified with '--revision', the
4755
 
    working tree basis revision is used. A revert operation affects only the
4756
 
    working tree, not any revision history like the branch and repository or
4757
 
    the working tree basis revision.
 
4722
    last committed revision is used.
4758
4723
 
4759
4724
    To remove only some changes, without reverting to a prior version, use
4760
4725
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
4761
4726
    will remove the changes introduced by the second last commit (-2), without
4762
4727
    affecting the changes introduced by the last commit (-1).  To remove
4763
4728
    certain changes on a hunk-by-hunk basis, see the shelve command.
4764
 
    To update the branch to a specific revision or the latest revision and
4765
 
    update the working tree accordingly while preserving local changes, see the
4766
 
    update command.
4767
4729
 
4768
 
    Uncommitted changes to files that are reverted will be discarded.
4769
 
    Howver, by default, any files that have been manually changed will be
4770
 
    backed up first.  (Files changed only by merge are not backed up.)  Backup
4771
 
    files have '.~#~' appended to their name, where # is a number.
 
4730
    By default, any files that have been manually changed will be backed up
 
4731
    first.  (Files changed only by merge are not backed up.)  Backup files have
 
4732
    '.~#~' appended to their name, where # is a number.
4772
4733
 
4773
4734
    When you provide files, you can use their current pathname or the pathname
4774
4735
    from the target revision.  So you can use revert to "undelete" a file by
5021
4982
                             "You have %d extra revisions:\n", 
5022
4983
                             len(local_extra)) %
5023
4984
                len(local_extra))
5024
 
            rev_tag_dict = {}
5025
 
            if local_branch.supports_tags():
5026
 
                rev_tag_dict = local_branch.tags.get_reverse_tag_dict()
5027
4985
            for revision in iter_log_revisions(local_extra,
5028
4986
                                local_branch.repository,
5029
 
                                verbose,
5030
 
                                rev_tag_dict):
 
4987
                                verbose):
5031
4988
                lf.log_revision(revision)
5032
4989
            printed_local = True
5033
4990
            status_code = 1
5041
4998
                             "You are missing %d revisions:\n",
5042
4999
                             len(remote_extra)) %
5043
5000
                len(remote_extra))
5044
 
            if remote_branch.supports_tags():
5045
 
                rev_tag_dict = remote_branch.tags.get_reverse_tag_dict()
5046
5001
            for revision in iter_log_revisions(remote_extra,
5047
5002
                                remote_branch.repository,
5048
 
                                verbose,
5049
 
                                rev_tag_dict):
 
5003
                                verbose):
5050
5004
                lf.log_revision(revision)
5051
5005
            status_code = 1
5052
5006
 
5309
5263
            else:
5310
5264
                if location is None:
5311
5265
                    if b.get_bound_location() is not None:
5312
 
                        raise errors.BzrCommandError(
5313
 
                            gettext('Branch is already bound'))
 
5266
                        raise errors.BzrCommandError(gettext('Branch is already bound'))
5314
5267
                    else:
5315
 
                        raise errors.BzrCommandError(
5316
 
                            gettext('No location supplied'
5317
 
                                    ' and no previous location known'))
 
5268
                        raise errors.BzrCommandError(gettext('No location supplied '
 
5269
                            'and no previous location known'))
5318
5270
        b_other = Branch.open(location)
5319
5271
        try:
5320
5272
            b.bind(b_other)
5524
5476
               help="Protocol to serve.",
5525
5477
               lazy_registry=('bzrlib.transport', 'transport_server_registry'),
5526
5478
               value_switches=True),
5527
 
        Option('listen',
5528
 
               help='Listen for connections on nominated address.', type=str),
5529
5479
        Option('port',
5530
 
               help='Listen for connections on nominated port.  Passing 0 as '
5531
 
                    'the port number will result in a dynamically allocated '
5532
 
                    'port.  The default port depends on the protocol.',
5533
 
               type=int),
 
5480
               help='Listen for connections on nominated port of the form '
 
5481
                    '[hostname:]portnumber.  Passing 0 as the port number will '
 
5482
                    'result in a dynamically allocated port.  The default port '
 
5483
                    'depends on the protocol.',
 
5484
               type=str),
5534
5485
        custom_help('directory',
5535
5486
               help='Serve contents of this directory.'),
5536
5487
        Option('allow-writes',
5546
5497
               help='Override the default idle client timeout (5min).'),
5547
5498
        ]
5548
5499
 
5549
 
    def run(self, listen=None, port=None, inet=False, directory=None,
5550
 
            allow_writes=False, protocol=None, client_timeout=None):
 
5500
    def get_host_and_port(self, port):
 
5501
        """Return the host and port to run the smart server on.
 
5502
 
 
5503
        If 'port' is None, None will be returned for the host and port.
 
5504
 
 
5505
        If 'port' has a colon in it, the string before the colon will be
 
5506
        interpreted as the host.
 
5507
 
 
5508
        :param port: A string of the port to run the server on.
 
5509
        :return: A tuple of (host, port), where 'host' is a host name or IP,
 
5510
            and port is an integer TCP/IP port.
 
5511
        """
 
5512
        host = None
 
5513
        if port is not None:
 
5514
            if ':' in port:
 
5515
                host, port = port.split(':')
 
5516
            port = int(port)
 
5517
        return host, port
 
5518
 
 
5519
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
 
5520
            protocol=None, client_timeout=None):
5551
5521
        from bzrlib import transport
5552
5522
        if directory is None:
5553
5523
            directory = os.getcwd()
5554
5524
        if protocol is None:
5555
5525
            protocol = transport.transport_server_registry.get()
 
5526
        host, port = self.get_host_and_port(port)
5556
5527
        url = transport.location_to_url(directory)
5557
5528
        if not allow_writes:
5558
5529
            url = 'readonly+' + url
5559
5530
        t = transport.get_transport_from_url(url)
5560
 
        protocol(t, listen, port, inet, client_timeout)
 
5531
        try:
 
5532
            protocol(t, host, port, inet, client_timeout)
 
5533
        except TypeError, e:
 
5534
            # We use symbol_versioning.deprecated_in just so that people
 
5535
            # grepping can find it here.
 
5536
            # symbol_versioning.deprecated_in((2, 5, 0))
 
5537
            symbol_versioning.warn(
 
5538
                'Got TypeError(%s)\ntrying to call protocol: %s.%s\n'
 
5539
                'Most likely it needs to be updated to support a'
 
5540
                ' "timeout" parameter (added in bzr 2.5.0)'
 
5541
                % (e, protocol.__module__, protocol),
 
5542
                DeprecationWarning)
 
5543
            protocol(t, host, port, inet)
5561
5544
 
5562
5545
 
5563
5546
class cmd_join(Command):
5699
5682
        if public_branch is None:
5700
5683
            public_branch = stored_public_branch
5701
5684
        elif stored_public_branch is None:
5702
 
            # FIXME: Should be done only if we succeed ? -- vila 2012-01-03
5703
5685
            branch.set_public_branch(public_branch)
5704
5686
        if not include_bundle and public_branch is None:
5705
5687
            raise errors.BzrCommandError(gettext('No public branch specified or'
6265
6247
                 possible_transports=possible_transports,
6266
6248
                 source_branch=branch).open_branch()
6267
6249
        else:
6268
 
            try:
6269
 
                to_branch = Branch.open(to_location,
6270
 
                    possible_transports=possible_transports)
6271
 
            except errors.NotBranchError:
6272
 
                to_branch = open_sibling_branch(control_dir, to_location,
6273
 
                    possible_transports=possible_transports)
 
6250
            to_branch = lookup_sibling_branch(control_dir, to_location)
6274
6251
        if revision is not None:
6275
6252
            revision = revision.as_revision_id(to_branch)
6276
6253
        switch.switch(control_dir, to_branch, force, revision_id=revision)
6473
6450
 
6474
6451
    takes_args = ["location?"]
6475
6452
 
6476
 
    takes_options = ['directory',
6477
 
        Option('force', help='Remove branch even if it is the active branch.')]
6478
 
 
6479
6453
    aliases = ["rmbranch"]
6480
6454
 
6481
 
    def run(self, directory=None, location=None, force=False):
6482
 
        br = open_nearby_branch(near=directory, location=location)
6483
 
        if not force and br.bzrdir.has_workingtree():
6484
 
            try:
6485
 
                active_branch = br.bzrdir.open_branch(name="")
6486
 
            except errors.NotBranchError:
6487
 
                active_branch = None
6488
 
            if (active_branch is not None and
6489
 
                br.control_url == active_branch.control_url):
6490
 
                raise errors.BzrCommandError(
6491
 
                    gettext("Branch is active. Use --force to remove it."))
6492
 
        br.bzrdir.destroy_branch(br.name)
 
6455
    def run(self, location=None):
 
6456
        if location is None:
 
6457
            location = "."
 
6458
        cdir = controldir.ControlDir.open_containing(location)[0]
 
6459
        cdir.destroy_branch()
6493
6460
 
6494
6461
 
6495
6462
class cmd_shelve(Command):
6725
6692
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6726
6693
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6727
6694
        ('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6728
 
        ('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
 
6695
        ('cmd_verify_signatures', [],
 
6696
                                        'bzrlib.commit_signature_commands'),
6729
6697
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6730
6698
        ]:
6731
6699
        builtin_command_registry.register_lazy(name, aliases, module_name)