← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

(jelmer) Make "bzr branches" support our shared-repo style of "sibling
 branches" too. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
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
 
        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
 
89
        target = control_dir.get_branch_reference()
97
90
    except errors.NotBranchError:
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
 
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
103
102
 
104
103
 
105
104
def _is_colocated(control_dir, possible_transports=None):
106
105
    """Check if the branch in control_dir is colocated.
107
106
 
108
107
    :param control_dir: Control directory
109
 
    :return: Boolean indicating whether 
 
108
    :return: Tuple with boolean indicating whether the branch is colocated
 
109
        and the full URL to the actual branch
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 relative to which to look up
136
 
        the name.
 
135
    :param control_dir: Control directory to find sibling branches from
137
136
    :param location: Name of the new branch
138
137
    :return: Full location to the new branch
139
138
    """
150
149
 
151
150
 
152
151
def open_sibling_branch(control_dir, location, possible_transports=None):
153
 
    """Open a branch, possibly a sibling.
 
152
    """Open a branch, possibly a sibling of another.
154
153
 
155
154
    :param control_dir: Control directory relative to which to lookup the
156
155
        location.
189
188
        possible_transports=possible_transports)
190
189
 
191
190
 
192
 
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
193
 
def tree_files(file_list, default_branch=u'.', canonicalize=True,
194
 
    apply_view=True):
195
 
    return internal_tree_files(file_list, default_branch, canonicalize,
196
 
        apply_view)
 
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
197
221
 
198
222
 
199
223
def tree_files_for_add(file_list):
261
285
    return rev_tree
262
286
 
263
287
 
264
 
# XXX: Bad function name; should possibly also be a class method of
265
 
# WorkingTree rather than a function.
266
 
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
267
 
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
268
 
    apply_view=True):
269
 
    """Convert command-line paths to a WorkingTree and relative paths.
270
 
 
271
 
    Deprecated: use WorkingTree.open_containing_paths instead.
272
 
 
273
 
    This is typically used for command-line processors that take one or
274
 
    more filenames, and infer the workingtree that contains them.
275
 
 
276
 
    The filenames given are not required to exist.
277
 
 
278
 
    :param file_list: Filenames to convert.
279
 
 
280
 
    :param default_branch: Fallback tree path to use if file_list is empty or
281
 
        None.
282
 
 
283
 
    :param apply_view: if True and a view is set, apply it or check that
284
 
        specified files are within it
285
 
 
286
 
    :return: workingtree, [relative_paths]
287
 
    """
288
 
    return WorkingTree.open_containing_paths(
289
 
        file_list, default_directory='.',
290
 
        canonicalize=True,
291
 
        apply_view=True)
292
 
 
293
 
 
294
288
def _get_view_info_for_change_reporter(tree):
295
289
    """Get the view information from a tree for change reporting."""
296
290
    view_info = None
1559
1553
                active_branch = dir.open_branch(name="")
1560
1554
            except errors.NotBranchError:
1561
1555
                active_branch = None
1562
 
            branches = dir.get_branches()
1563
1556
            names = {}
1564
 
            for name, branch in branches.iteritems():
 
1557
            for name, branch in iter_sibling_branches(dir):
1565
1558
                if name == "":
1566
1559
                    continue
1567
1560
                active = (active_branch is not None and