1
=== added file 'bzrlib/loggraphviz.py'
2
--- bzrlib/loggraphviz.py	1970-01-01 00:00:00 +0000
3
+++ bzrlib/loggraphviz.py	2010-11-18 10:15:44 +0000
4
@@ -0,0 +1,1648 @@
5
1
# Copyright (C) 2009, 2010 Canonical Ltd
6
2
#
7
3
# This program is free software; you can redistribute it and/or
8
4
# modify it under the terms of the GNU General Public License
9
5
# as published by the Free Software Foundation; either version 2
10
6
# of the License, or (at your option) any later version.
11
7
#
12
8
# This program is distributed in the hope that it will be useful,
13
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
14
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
11
# GNU General Public License for more details.
16
12
#
17
13
# You should have received a copy of the GNU General Public License
18
14
# along with this program; if not, write to the Free Software
19
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
16
21
17
"""
22
18
Layout a revision graph for visual representation, allowing for filtering and
23
19
collapsible branches.
24
20
25
21
Usage example
26
22
=============
27
23
28
24
.. python::
29
25
  bi = loggraphviz.BranchInfo('branch-label', tree, branch)
30
26
  graph_viz = loggraphviz.GraphVizLoader([bi], bi, False)
31
27
  graph_viz.load()
32
28
  state = loggraphviz.GraphVizFilterState(graph_viz)
33
29
  computed = graph_viz.compute_viz(state)
34
30
35
31
"""
36
32
37
33
import gc
38
34
from itertools import izip
39
35
40
36
from bzrlib import errors
41
37
from bzrlib.bzrdir import BzrDir
42
38
from bzrlib.transport.local import LocalTransport
43
39
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
44
40
from bzrlib.graph import (
45
41
    Graph,
46
42
    StackedParentsProvider,
47
43
    KnownGraph,
48
44
    DictParentsProvider,
49
45
    )
50
46
51
47
52
48
class BranchInfo(object):
53
49
    """Wrapper for a branch, it's working tree, if available, and a label."""
54
50
    
55
51
    def __init__(self, label, tree, branch, index=None):
56
52
        self.label = label
57
53
        self.tree = tree
58
54
        self.branch = branch
59
55
        self.index = index
60
56
    
61
57
    def __hash__(self):
62
58
        return self.branch.base.__hash__()
63
59
64
60
    def __eq__(self, other):
65
61
        if isinstance(other, BranchInfo):
66
62
            return self.branch.base.__eq__(other.branch.base)
67
63
        return False
68
64
69
65
70
66
class RevisionData(object):
71
67
    """
72
68
    Container for data for a revision in the graph that gets calculated
73
69
    when the graph is loaded.
74
70
    """
75
71
    
76
72
    # Instance of this object are typically named "rev".
77
73
    
78
74
    __slots__ = ["index", "_merge_sort_node", "branch", "_revno_str",
79
75
                 "merges", "merged_by", 'branch_id', 'color']
80
76
    
81
77
    def __init__(self, index, merge_sort_node):
82
78
        """Create a new RevisionData instance."""
83
79
        self.index = index
84
80
        self._merge_sort_node = merge_sort_node
85
81
        self.branch = None
86
82
        self._revno_str = None
87
83
        self.merges = []
88
84
        """Revision indexes that this revision merges"""
89
85
        self.merged_by = None
90
86
        """Revision index that merges this revision."""
91
87
        self.branch_id = self._merge_sort_node.revno[0:-1]
92
88
        self.color = reduce(lambda x, y: x + y, self.branch_id, 0)
93
89
    
94
90
    revid = property(lambda self: self._merge_sort_node.key)
95
91
    merge_depth = property(lambda self: self._merge_sort_node.merge_depth)
96
92
    revno_sequence = property(lambda self: self._merge_sort_node.revno)
97
93
    end_of_merge = property(lambda self: self._merge_sort_node.end_of_merge)
98
94
    
99
95
    def get_revno_str(self):
100
96
        if self._revno_str is None:
101
97
            self._revno_str = ".".join(["%d" % (revno)
102
98
                                for revno in self.revno_sequence])
103
99
            if self.revid.startswith(CURRENT_REVISION):
104
100
                self._revno_str += " ?"
105
101
        return self._revno_str
106
102
    revno_str = property(get_revno_str)
107
103
    
108
104
    def __repr__(self):
109
105
        return "%s <%s %s>" % (self.__class__.__name__, self.revno_str,
110
106
                              self.revid)
111
107
112
108
class BranchLine(object):
113
109
    """Container for data for a branch line, aka merge line."""
114
110
    
115
111
    __slots__ = ["branch_id", "revs", "merges", "merged_by",
116
112
                 "color", "merge_depth"]
117
113
    
118
114
    def __init__(self, branch_id):
119
115
        self.branch_id = branch_id
120
116
        self.revs = []
121
117
        self.merges = []
122
118
        self.merged_by = []
123
119
        self.merge_depth = 0
124
120
125
121
    def __repr__(self):
126
122
        return "%s <%s>" % (self.__class__.__name__, self.branch_id)
127
123
128
124
129
125
class GhostRevisionError(errors.InternalBzrError):
130
126
131
127
    _fmt = "{%(revision_id)s} is a ghost."
132
128
133
129
    def __init__(self, revision_id):
134
130
        errors.BzrError.__init__(self)
135
131
        self.revision_id = revision_id
136
132
137
133
138
134
class GraphVizLoader(object):
139
135
    """
140
136
    Loads graph for branches and provides computed layout for visual
141
137
    representation.
142
138
    """
143
139
    
144
140
    # Most list/dicts related to revisions are unfiltered. When we do a graph
145
141
    # layout, we filter these revisions. A revision may be filter out because:
146
142
    # * It's branch is hidden (or collapsed).
147
143
    # * We have a specified file_id(s), and the revision does not touch the
148
144
    #   file_id(s).
149
145
    # * We have a search, and the revision does not match the search.
150
146
    #
151
147
    # The main list of unfiltered revisions is self.revisions. A revisions
152
148
    # index in revisions are normally called index. The main list of filtered
153
149
    # revisions is filtered_revs. Revision indexes in this list are called
154
150
    # f_index.
155
151
    
156
152
    def __init__(self, branches, primary_bi, no_graph):
157
153
        self.branches = branches
158
154
        """List of BranchInfo for each branch."""
159
155
        self.primary_bi = primary_bi
160
156
        self.no_graph = no_graph
161
157
        
162
158
        self.repos = []
163
159
        self.local_repo_copies = []
164
160
        """A list of repositories that revisions will be attempted to be loaded        
165
161
        from first."""
166
162
        
167
163
        self.revid_head_info = {}
168
164
        """Dict with a keys of head revid and value of
169
165
            (list of (branch, label),
170
166
             list of revids that are unique to this head)
171
167
            
172
168
            We can't just store the BranchInfo, because the label may have
173
169
            have addition text in it, e.g. "Working Tree", "Pending Merges"
174
170
        """
175
171
        
176
172
        self.revid_branch_info = {}
177
173
        
178
174
        self.ghosts = set()
179
175
        
180
176
        self.revisions = []
181
177
        """List of RevisionInfo from merge_sort."""
182
178
        
183
179
        self.revid_rev = {}
184
180
        self.graph_children = {}
185
181
        
186
182
        self.tags = {}      # map revid -> tags set
187
183
    
188
184
    def load(self):
189
185
        # Get a unique list of repositories. If the url is the same,
190
186
        # we consider it the same repositories
191
187
        repo_urls = set()
192
188
        for bi in self.branches:
193
189
            repo = bi.branch.repository
194
190
            if repo.base not in repo_urls:
195
191
                repo_urls.add(repo.base)
196
192
                self.repos.append(repo)
197
193
        
198
194
        no_local_repos = True
199
195
        for repo in self.repos:
200
196
            if repo_is_local(repo):
201
197
                no_local_repos = False
202
198
        if no_local_repos:
203
199
            self.load_current_dir_repo()
204
200
        self.repos.sort(key=lambda repo: not repo_is_local(repo))
205
201
206
202
        self.lock_read_branches()
207
203
        try:
208
204
            head_revids, graph_parents = self.load_graph_parents()
209
205
            self.process_graph_parents(head_revids, graph_parents)
210
206
            
211
207
            self.compute_head_info()
212
208
            del self.graph
213
209
            
214
210
            if not self.no_graph:
215
211
                self.compute_branch_lines()
216
212
                self.compute_merge_info()
217
213
            
218
214
            self.load_tags()
219
215
        finally:
220
216
            self.unlock_branches()
221
217
    
222
218
    
223
219
    def load_current_dir_repo(self):
224
220
        # There are no local repositories. Try open the repository
225
221
        # of the current directory, and try load revisions data from
226
222
        # this before trying from remote repositories. This makes
227
223
        # the common use case of viewing a remote branch that is
228
224
        # related to the current branch much faster, because most
229
225
        # of the revision can be loaded from the local repository.
230
226
        try:
231
227
            bzrdir, relpath = BzrDir.open_containing(u".")
232
228
            repo = bzrdir.find_repository()
233
229
            self.repos.add(repo)
234
230
            self.local_repo_copies.append(repo)
235
231
        except Exception:
236
232
            pass
237
233
    
238
234
    def update_ui(self):
239
235
        pass
240
236
    
241
237
    def throbber_show(self):
242
238
        pass
243
239
    
244
240
    def throbber_hide(self):
245
241
        pass
246
242
247
243
    def lock_read_branches(self):
248
244
        for bi in self.branches:
249
245
            bi.branch.lock_read()
250
246
        for repo in self.repos:
251
247
            repo.lock_read()
252
248
    
253
249
    def unlock_branches(self):
254
250
        for bi in self.branches:
255
251
            bi.branch.unlock()
256
252
        for repo in self.repos:
257
253
            repo.unlock()
258
254
    
259
255
    #def lock_read_repos(self):
260
256
    #    for repo in self.repos.itervalues():
261
257
    #        repo.lock_read()
262
258
    #
263
259
    #def unlock_repos(self):
264
260
    #    for repo in self.repos.itervalues():
265
261
    #        repo.unlock()
266
262
    
267
263
    def load_tags(self):
268
264
        self.tags = {}
269
265
        for bi in self.branches:
270
266
            # revid to tags map
271
267
            branch_tags = bi.branch.tags.get_reverse_tag_dict()
272
268
            for revid, tags in branch_tags.iteritems():
273
269
                if revid in self.tags:
274
270
                    self.tags[revid].update(set(tags))
275
271
                else:
276
272
                    self.tags[revid] = set(tags)
277
273
278
274
    def append_head_info(self, revid, branch_info, tag):
279
275
        if not revid == NULL_REVISION:
280
276
            if not revid in self.revid_head_info:
281
277
                self.revid_head_info[revid] = ([], [])
282
278
            self.revid_head_info[revid][0].append((branch_info, tag))
283
279
            
284
280
            # So that early calls to get_revid_branch work
285
281
            self.revid_branch_info[revid] = branch_info
286
282
287
283
    def load_branch_heads(self, bi):
288
284
        branch_heads = []
289
285
        
290
286
        def append_head_info(revid, branch_info, label):
291
287
            self.append_head_info(revid, branch_info, label)
292
288
            branch_heads.append(revid)
293
289
        
294
290
        if len(self.branches) > 0:
295
291
            label = bi.label
296
292
        else:
297
293
            label = None
298
294
        
299
295
        branch_last_revision = bi.branch.last_revision()
300
296
        append_head_info(branch_last_revision, bi, bi.label)
301
297
        self.update_ui()
302
298
        
303
299
        if bi.tree:
304
300
            parent_ids = bi.tree.get_parent_ids()
305
301
            if parent_ids:
306
302
                # first parent is last revision of the tree
307
303
                revid = parent_ids[0]
308
304
                if revid != branch_last_revision:
309
305
                    # working tree is out of date
310
306
                    if label:
311
307
                        wt_label = "%s - Working Tree" % label
312
308
                    else:
313
309
                        wt_label = "Working Tree"
314
310
                    append_head_info(revid, bi, wt_label)
315
311
                # other parents are pending merges
316
312
                for revid in parent_ids[1:]:
317
313
                    if label:
318
314
                        pm_label = "%s - Pending Merge" % label
319
315
                    else:
320
316
                        pm_label = "Pending Merge"
321
317
                    append_head_info(revid, bi, pm_label)
322
318
            self.update_ui()
323
319
        return branch_heads, branch_heads, ()
324
320
    
325
321
    def load_graph_parents(self):
326
322
        """Load the heads of the graph, and the graph parents"""
327
323
        
328
324
        extra_parents = {}
329
325
        branches_heads = []
330
326
        
331
327
        def load_branch_heads(bi, insert_at_begin=False):
332
328
            load_heads, sort_heads, extra_parents_ = self.load_branch_heads(bi)
333
329
            for key, parents in extra_parents_:
334
330
                extra_parents[key] = parents
335
331
            if insert_at_begin:
336
332
                branches_heads.insert(0, (load_heads, sort_heads))
337
333
            else:
338
334
                branches_heads.append((load_heads, sort_heads))
339
335
        
340
336
        for bi in self.branches:
341
337
            # Don't do the primary branch, as that will be inserted later at
342
338
            # the first position.
343
339
            if bi != self.primary_bi:
344
340
                load_branch_heads(bi)
345
341
        
346
342
        if len(branches_heads) >= 2:
347
343
            head_revids = [revid for load_heads, sort_heads in branches_heads
348
344
                                 for revid in load_heads]
349
345
            head_revs = self.load_revisions(head_revids)
350
346
            
351
347
            get_max_timestamp = lambda branch_heads: max(
352
348
                [head_revs[revid].timestamp for revid in branch_heads[0]])
353
349
            branches_heads.sort(key=get_max_timestamp, reverse=True)
354
350
        
355
351
        if self.primary_bi:
356
352
            load_branch_heads(self.primary_bi, True)
357
353
        
358
354
        load_heads = [revid for load_heads_, sort_heads_ in branches_heads
359
355
                      for revid in load_heads_]
360
356
        sort_heads = [revid for load_heads_, sort_heads_ in branches_heads
361
357
                      for revid in sort_heads_]
362
358
        
363
359
        parents_providers = [repo._make_parents_provider() \
364
360
                             for repo in self.repos]
365
361
        parents_providers.append(DictParentsProvider(extra_parents))
366
362
        self.graph = Graph(StackedParentsProvider(parents_providers))
367
363
        
368
364
        return sort_heads, self.graph.iter_ancestry(sort_heads)
369
365
    
370
366
    def process_graph_parents(self, head_revids, graph_parents_iter):
371
367
        graph_parents = {}
372
368
        self.ghosts = set()
373
369
        
374
370
        for (revid, parent_revids) in graph_parents_iter:
375
371
            if revid == NULL_REVISION:
376
372
                continue
377
373
            if parent_revids is None:
378
374
                #Ghost
379
375
                graph_parents[revid] = ()
380
376
                self.ghosts.add(revid)
381
377
            elif parent_revids == (NULL_REVISION,):
382
378
                graph_parents[revid] = ()
383
379
            else:
384
380
                graph_parents[revid] = parent_revids
385
381
            if len(graph_parents) % 100 == 0:
386
382
                self.update_ui()
387
383
        
388
384
        graph_parents["top:"] = head_revids
389
385
390
386
        if len(graph_parents) > 0:
391
387
            enabled = gc.isenabled()
392
388
            if enabled:
393
389
                gc.disable()
394
390
            
395
391
            def make_kg():
396
392
                return KnownGraph(graph_parents)
397
393
            self.known_graph = make_kg()
398
394
            
399
395
            merge_sorted_revisions = self.known_graph.merge_sort('top:')
400
396
            # So far, we are a bit faster than the pure-python code. But the
401
397
            # last step hurts. Specifically, we take
402
398
            #   377ms KnownGraph(self.graph_parents)
403
399
            #   263ms kg.merge_sort() [640ms combined]
404
400
            #  1322ms self.revisions = [...]
405
401
            # vs 
406
402
            #  1152ms tsort.merge_sort(self.graph_parents)
407
403
            #   691ms self.revisions = [...]
408
404
            #
409
405
            # It is a gc thing... :(
410
406
            # Adding gc.disable() / gc.enable() around this whole loop changes
411
407
            # things to be:
412
408
            #   100ms   KnownGraph(self.graph_parents)
413
409
            #    77ms   kg.merge_sort() [177ms combined]
414
410
            #   174ms   self.revisions = [...]
415
411
            # vs
416
412
            #   639ms   tsort.merge_sort(self.graph_parents)
417
413
            #   150ms   self.revisions = [...]
418
414
            # Also known as "wow that's a lot faster". This is because KG()
419
415
            # creates a bunch of Python objects, then merge_sort() creates a
420
416
            # bunch more. And then self.revisions() creates another whole set.
421
417
            # And all of these are moderately long lived, so you have a *lot*
422
418
            # of allocations without removals (which triggers the gc checker
423
419
            # over and over again.) And they probably don't live in cycles
424
420
            # anyway, so you can skip it for now, and just run at the end.
425
421
            
426
422
            # self.revisions *is* a little bit slower. Probably because pyrex
427
423
            # MergeSortNodes use long integers rather than PyIntObject and thus
428
424
            # create them on-the-fly.
429
425
430
426
            # Get rid of the 'top:' revision
431
427
            merge_sorted_revisions.pop(0)
432
428
            self.revisions = [RevisionData(index, node)
433
429
                for index, node in enumerate(merge_sorted_revisions)]
434
430
            if enabled:
435
431
                gc.enable()
436
432
        else:
437
433
            self.revisions = ()
438
434
        
439
435
        self.revid_rev = {}
440
436
        self.revno_rev = {}
441
437
        
442
438
        self.max_mainline_revno = 0
443
439
        
444
440
        for rev in self.revisions:
445
441
            self.max_mainline_revno = max(self.max_mainline_revno, 
446
442
                                          rev.revno_sequence[0])
447
443
            self.revid_rev[rev.revid] = rev
448
444
            self.revno_rev[rev.revno_sequence] = rev
449
445
        
450
446
    def branch_id_sort_key(self, x):
451
447
        merge_depth = self.branch_lines[x].merge_depth
452
448
        
453
449
        # Note: This greatly affects the layout of the graph.
454
450
        #
455
451
        # Branch line that have a smaller merge depth should be to the left
456
452
        # of those with bigger merge depths.
457
453
        #
458
454
        # For branch lines that have the same parent in the mainline -
459
455
        # those with bigger branch numbers to be to the rights. E.g. for
460
456
        # the following dag, you want the graph to appear as on the left,
461
457
        # not as on the right:
462
458
        #
463
459
        # 3     F_       F
464
460
        #       | \      |\
465
461
        # 1.2.1 |  E     | E
466
462
        #       |  |     | \
467
463
        # 2     D  |     D_|
468
464
        #       |\ |     | +_
469
465
        # 1.1.2 | C|     | | C
470
466
        #       | |/     |  \|
471
467
        # 1.1.1 | B      |   B
472
468
        #       |/       | /
473
469
        # 1     A        A
474
470
        #
475
471
        # Otherwise, those with a greater mainline parent revno should
476
472
        # appear to the left.
477
473
        
478
474
        if len(x) == 0:
479
475
            return (merge_depth)
480
476
        else:
481
477
            return (merge_depth, -x[0], x[1])
482
478
    
483
479
    def compute_branch_lines(self):
484
480
        self.branch_lines = {}
485
481
        
486
482
        """A list of branch lines (aka merge lines).
487
483
        
488
484
        For a revisions, the revision number less the least significant
489
485
        digit is the branch_id, and used as the key for the dict. Hence
490
486
        revision with the same revision number less the least significant
491
487
        digit are considered to be in the same branch line. e.g.: for
492
488
        revisions 290.12.1 and 290.12.2, the branch_id would be 290.12,
493
489
        and these two revisions will be in the same branch line.
494
490
        
495
491
        """
496
492
        
497
493
        self.branch_ids = []
498
494
        """List of branch ids, sorted in the order that the branches will
499
495
        be shown, from left to right on the graph."""
500
496
        
501
497
        for rev in self.revisions:
502
498
            
503
499
            branch_line = None
504
500
            if rev.branch_id not in self.branch_lines:
505
501
                branch_line = BranchLine(rev.branch_id)
506
502
                self.branch_lines[rev.branch_id] = branch_line
507
503
            else:
508
504
                branch_line = self.branch_lines[rev.branch_id]
509
505
            
510
506
            branch_line.revs.append(rev)
511
507
            branch_line.merge_depth = max(rev.merge_depth,
512
508
                                          branch_line.merge_depth)
513
509
            rev.branch = branch_line
514
510
        
515
511
        self.branch_ids = self.branch_lines.keys()
516
512
        
517
513
        self.branch_ids.sort(key=self.branch_id_sort_key)
518
514
    
519
515
    def compute_merge_info(self):
520
516
        
521
517
        def set_merged_by(rev, merged_by, merged_by_rev, do_branches=False):
522
518
            if merged_by is None:
523
519
                return
524
520
            
525
521
            if merged_by_rev is None:
526
522
                merged_by_rev = self.revisions[merged_by]
527
523
            rev.merged_by = merged_by
528
524
            merged_by_rev.merges.append(rev.index)
529
525
            
530
526
            if do_branches:
531
527
                branch_id = rev.branch_id
532
528
                branch_merged_by = self.branch_lines[branch_id].merged_by
533
529
                merged_by_branch_id = self.revisions[merged_by].branch_id
534
530
                merged_by_branch_merges = \
535
531
                    self.branch_lines[merged_by_branch_id].merges
536
532
                
537
533
                if not branch_id in merged_by_branch_merges:
538
534
                    merged_by_branch_merges.append(branch_id)
539
535
                if not merged_by_branch_id in branch_merged_by:
540
536
                    branch_merged_by.append(merged_by_branch_id)
541
537
        
542
538
        for rev in self.revisions:
543
539
            
544
540
            parents = [self.revid_rev[parent] for parent in
545
541
                       self.known_graph.get_parent_keys(rev.revid)]
546
542
            
547
543
            if len(parents) > 0:
548
544
                if rev.branch_id == parents[0].branch_id:
549
545
                    set_merged_by(parents[0], rev.merged_by, None)
550
546
            
551
547
            for parent in parents[1:]:
552
548
                if rev.merge_depth <= parent.merge_depth:
553
549
                    set_merged_by(parent, rev.index, rev, do_branches=True)
554
550
        
555
551
    def compute_head_info(self):
556
552
        def get_revid_head(heads):
557
553
            map = {}
558
554
            for i in xrange(len(heads)):
559
555
                prev_revids = [revid for revid, head in heads[:i]]
560
556
                unique_ancestors = self.graph.find_unique_ancestors(
561
557
                    heads[i][0], prev_revids)
562
558
                for ancestor_revid in unique_ancestors:
563
559
                    map[ancestor_revid] = heads[i][1]
564
560
            return map
565
561
        
566
562
        if len(self.branches) > 1:
567
563
            head_revid_branch_info = sorted(
568
564
                [(revid, branch_info)
569
565
                 for revid, (head_info, ur) in self.revid_head_info.iteritems()
570
566
                 for (branch_info, tag) in head_info],
571
567
                key=lambda x: not repo_is_local(x[1].branch.repository))
572
568
            self.revid_branch_info = get_revid_head(head_revid_branch_info)
573
569
        else:
574
570
            self.revid_branch_info = {}
575
571
        
576
572
        head_count = 0
577
573
        for head_info, ur in self.revid_head_info.itervalues():
578
574
            head_count += len(head_info)
579
575
        
580
576
        if head_count > 1:
581
577
            # Populate unique revisions for heads
582
578
            for revid, (head_info, ur) in self.revid_head_info.iteritems():
583
579
                rev = None
584
580
                if revid in self.revid_rev:
585
581
                    rev = self.revid_rev[revid]
586
582
                if rev and rev.merged_by:
587
583
                    # This head has been merged.
588
584
                    # d
589
585
                    # |\
590
586
                    # b c
591
587
                    # |/
592
588
                    # a
593
589
                    # if revid == c,then we want other_revids = [b]
594
590
                    
595
591
                    merged_by_revid = self.revisions[rev.merged_by].revid
596
592
                    other_revids = [self.known_graph
597
593
                                    .get_parent_keys(merged_by_revid)[0]]
598
594
                else:
599
595
                    other_revids = [other_revid for other_revid \
600
596
                        in self.revid_head_info.iterkeys() \
601
597
                        if not other_revid == revid]
602
598
                ur.append(revid)
603
599
                ur.extend([revid for revid \
604
600
                    in self.graph.find_unique_ancestors(revid, other_revids) \
605
601
                    if not revid == NULL_REVISION and revid in self.revid_rev])
606
602
                ur.sort(key=lambda x: self.revid_rev[x].index)
607
603
    
608
604
    def compute_viz(self, state):
609
605
        
610
606
        # Overview:
611
607
        # Work out which revision need to be displayed.
612
608
        # Create ComputedGraphViz and ComputedRevisionData objects
613
609
        # Assign columns for branches, and lines that go between branches.
614
610
        #   These are intermingled, because some of the lines need to come
615
611
        #   before it's branch, and others need to come after. Other lines
616
612
        #   (such a the line from the last rev in a branch) are treated a
617
613
        #   special cases.
618
614
        # Return ComputedGraphViz object
619
615
        gc_enabled = gc.isenabled()
620
616
        gc.disable()
621
617
        try:
622
618
            computed = ComputedGraphViz(self)
623
619
            computed.filtered_revs = [ComputedRevisionData(rev) for rev in
624
620
                                      state.get_filtered_revisions()]
625
621
            
626
622
            c_revisions = computed.revisions
627
623
            for f_index, c_rev in enumerate(computed.filtered_revs):
628
624
                c_revisions[c_rev.rev.index] = c_rev
629
625
                c_rev.f_index = f_index
630
626
            
631
627
            for (revid, (head_info,
632
628
                         unique_revids)) in self.revid_head_info.iteritems():
633
629
                
634
630
                for unique_revid in unique_revids:
635
631
                    rev = self.revid_rev[unique_revid]
636
632
                    c_rev = c_revisions[rev.index]
637
633
                    if c_rev is not None:
638
634
                        c_rev.branch_labels.extend(head_info)
639
635
                        break
640
636
        finally:
641
637
            if gc_enabled:
642
638
                gc.enable()
643
639
        
644
640
        if self.no_graph:
645
641
            for c_rev in computed.filtered_revs:
646
642
                c_rev.col_index = c_rev.rev.merge_depth * 0.5
647
643
            return computed
648
644
        
649
645
        # This will hold a tuple of (child, parent, col_index, direct) for each
650
646
        # line that needs to be drawn. If col_index is not none, then the line
651
647
        # is drawn along that column, else the the line can be drawn directly
652
648
        # between the child and parent because either the child and parent are
653
649
        # in the same branch line, or the child and parent are 1 row apart.
654
650
        lines = []
655
651
        lines_by_column = []
656
652
        
657
653
        def branch_line_col_search_order(start_col_index):
658
654
            for col_index in range(start_col_index, len(lines_by_column)):
659
655
                yield col_index
660
656
            #for col_index in range(parent_col_index-1, -1, -1):
661
657
            #    yield col_index
662
658
        
663
659
        def line_col_search_order(parent_col_index, child_col_index):
664
660
            if parent_col_index is not None and child_col_index is not None:
665
661
                max_index = max(parent_col_index, child_col_index)
666
662
                min_index = min(parent_col_index, child_col_index)
667
663
                # First yield the columns between the child and parent.
668
664
                for col_index in range(max_index, min_index - 1, -1):
669
665
                    yield col_index
670
666
            elif child_col_index is not None:
671
667
                max_index = child_col_index
672
668
                min_index = child_col_index
673
669
                yield child_col_index
674
670
            elif parent_col_index is not None:
675
671
                max_index = parent_col_index
676
672
                min_index = parent_col_index
677
673
                yield parent_col_index
678
674
            else:
679
675
                max_index = 0
680
676
                min_index = 0
681
677
                yield 0
682
678
            i = 1
683
679
            # then yield the columns on either side.
684
680
            while max_index + i < len(lines_by_column) or \
685
681
                  min_index - i > -1:
686
682
                if max_index + i < len(lines_by_column):
687
683
                    yield max_index + i
688
684
                #if min_index - i > -1:
689
685
                #    yield min_index - i
690
686
                i += 1
691
687
        
692
688
        def is_col_free_for_range(col_index, child_f_index, parent_f_index):
693
689
            return not any(
694
690
                range_overlaps(child_f_index, parent_f_index,
695
691
                               line_child_f_index, line_parent_f_index)
696
692
                for line_child_f_index, line_parent_f_index
697
693
                in lines_by_column[col_index])
698
694
        
699
695
        def find_free_column(col_search_order, child_f_index, parent_f_index):
700
696
            for col_index in col_search_order:
701
697
                if is_col_free_for_range(col_index,
702
698
                                             child_f_index, parent_f_index):
703
699
                    break
704
700
            else:
705
701
                # No free columns found. Add an empty one on the end.
706
702
                col_index = len(lines_by_column)
707
703
                lines_by_column.append([])
708
704
            return col_index
709
705
        
710
706
        def append_line(child, parent, direct, col_index=None):
711
707
            lines.append((child, parent, col_index, direct))
712
708
            
713
709
            if col_index is not None:
714
710
                lines_by_column[int(round(col_index))].append(
715
711
                    (child.f_index, parent.f_index))
716
712
        
717
713
        def find_visible_parent(c_rev, parent, twisty_hidden_parents):
718
714
            if c_revisions[parent.index] is not None:
719
715
                return (c_rev, c_revisions[parent.index], True)
720
716
            else:
721
717
                if parent.index in twisty_hidden_parents:
722
718
                    # no need to draw a line if there is a twisty,
723
719
                    # except if this is the last in the branch.
724
720
                    return None
725
721
                # The parent was not visible. Search for a ancestor
726
722
                # that is. Stop searching if we make a hop, i.e. we
727
723
                # go away from our branch, and we come back to it.
728
724
                has_seen_different_branch = False
729
725
                while c_revisions[parent.index] is None:
730
726
                    if not parent.branch_id == c_rev.rev.branch_id:
731
727
                        has_seen_different_branch = True
732
728
                    # find grand parent.
733
729
                    g_parent_ids = (self.known_graph
734
730
                                    .get_parent_keys(parent.revid))
735
731
                    
736
732
                    if len(g_parent_ids) == 0:
737
733
                        return None
738
734
                    else:
739
735
                        parent = self.revid_rev[g_parent_ids[0]]
740
736
                    
741
737
                    if (has_seen_different_branch and
742
738
                        parent.branch_id == branch_id):
743
739
                        # We have gone away and come back to our
744
740
                        # branch. Stop.
745
741
                        return None
746
742
                if parent:
747
743
                    # Not Direct
748
744
                    return (c_rev, c_revisions[parent.index], False)
749
745
        
750
746
        def append_branch_parent_lines(branch_rev_visible_parents):
751
747
            groups = group_overlapping(branch_rev_visible_parents)
752
748
            for parents, start, end, group_key in groups:
753
749
                # Since all parents go from the same branch line to the
754
750
                # same branch line, we can use the col indexes of the
755
751
                # parent.
756
752
                if end - start == 1:
757
753
                    col_index = None
758
754
                else:
759
755
                    col_search_order = line_col_search_order(
760
756
                        parents[0][1].col_index, parents[0][0].col_index)                        
761
757
                    col_index = find_free_column(col_search_order,
762
758
                                                 start, end)
763
759
                
764
760
                col_offset_increment = 1.0 / len(parents)
765
761
                for i, (c_rev, parent_c_rev, direct) in enumerate(parents):
766
762
                    if col_index is None:
767
763
                        col_index_offset = None
768
764
                    else:
769
765
                        col_index_offset = (col_index - 0.5 +
770
766
                                            (i * col_offset_increment) +
771
767
                                            (col_offset_increment / 2))
772
768
                    append_line(c_rev, parent_c_rev,
773
769
                                direct, col_index_offset)
774
770
        
775
771
        for branch_id in self.branch_ids:
776
772
            if not branch_id in state.branch_line_state:
777
773
                continue
778
774
            
779
775
            branch_line = self.branch_lines[branch_id]
780
776
            branch_revs = [c_revisions[rev.index]
781
777
                           for rev in branch_line.revs
782
778
                           if c_revisions[rev.index] is not None]
783
779
            
784
780
            if not branch_revs:
785
781
                continue
786
782
            
787
783
            branch_rev_visible_parents_post = []
788
784
            branch_rev_visible_parents_pre = []
789
785
            # Lists of ([(c_rev, parent_c_rev, is_direct)],
790
786
            #            start, end, group_key]
791
787
            
792
788
            last_c_rev = branch_revs[-1]
793
789
            last_rev_left_parents = (self.known_graph
794
790
                                     .get_parent_keys(last_c_rev.rev.revid))
795
791
            if last_rev_left_parents:
796
792
                last_parent = find_visible_parent(
797
793
                    last_c_rev, self.revid_rev[last_rev_left_parents[0]], [])
798
794
            else:
799
795
                last_parent = None
800
796
            
801
797
            sprout_with_lines = {}
802
798
            
803
799
            merged_by_max_col_index = 0
804
800
            
805
801
            # In this loop:
806
802
            # * Populate twisty_branch_ids and twisty_state
807
803
            # * Find visible parents.
808
804
            # * Append lines that go before the branch line.
809
805
            # * Append lines to children for sprouts.
810
806
            for c_rev in branch_revs:
811
807
                rev = c_rev.rev
812
808
                
813
809
                if rev.merged_by is not None:
814
810
                    merged_by_c_rev = c_revisions[rev.merged_by]
815
811
                    if merged_by_c_rev:
816
812
                        merged_by_max_col_index = max(
817
813
                            merged_by_max_col_index, merged_by_c_rev.col_index)
818
814
                
819
815
                parents = [self.revid_rev[parent_revid] for parent_revid in 
820
816
                           self.known_graph.get_parent_keys(rev.revid)]
821
817
                
822
818
                twisty_hidden_parents = []
823
819
                # Find and add necessary twisties
824
820
                for parent in parents:
825
821
                    if parent.branch_id == branch_id:
826
822
                        continue
827
823
                    if parent.branch_id == ():
828
824
                        continue
829
825
                    if parent.branch_id in branch_line.merged_by:
830
826
                        continue
831
827
                    parent_branch = self.branch_lines[parent.branch_id]
832
828
                    # Does this branch have any visible revisions
833
829
                    pb_visible = (parent_branch.branch_id in
834
830
                                  state.branch_line_state)
835
831
                    for pb_rev in parent_branch.revs:
836
832
                        if pb_visible:
837
833
                            visible = c_revisions[pb_rev.index] is not None
838
834
                        else:
839
835
                            visible = state\
840
836
                                .get_revision_visible_if_branch_visible(pb_rev)
841
837
                        if visible:
842
838
                            (c_rev.twisty_expands_branch_ids
843
839
                             .append(parent_branch.branch_id))
844
840
                            if not pb_visible:
845
841
                                twisty_hidden_parents.append(parent.index)
846
842
                            break
847
843
                
848
844
                # Work out if the twisty needs to show a + or -. If all
849
845
                # twisty_branch_ids are visible, show - else +.
850
846
                if len(c_rev.twisty_expands_branch_ids) > 0:
851
847
                    c_rev.twisty_state = True
852
848
                    for twisty_branch_id in c_rev.twisty_expands_branch_ids:
853
849
                        if not twisty_branch_id in state.branch_line_state:
854
850
                            c_rev.twisty_state = False
855
851
                            break
856
852
                
857
853
                # Don't include left hand parents All of these parents in the
858
854
                # branch can be drawn with one line.
859
855
                parents = parents[1:]
860
856
                
861
857
                branch_id_sort_key = self.branch_id_sort_key(branch_id)
862
858
                for i, parent in enumerate(parents):
863
859
                    parent_info = find_visible_parent(c_rev, parent,
864
860
                                                      twisty_hidden_parents)
865
861
                    if parent_info:
866
862
                        c_rev, parent_c_rev, direct = parent_info
867
863
                        if (last_parent and
868
864
                            parent_c_rev.f_index <= last_parent[1].f_index and
869
865
                            self.branch_id_sort_key(parent_c_rev.rev.branch_id)
870
866
                            < branch_id_sort_key):
871
867
                            # This line goes before the branch line
872
868
                            dest = branch_rev_visible_parents_pre
873
869
                        else:
874
870
                            # This line goes after
875
871
                            dest = branch_rev_visible_parents_post
876
872
                        
877
873
                        line_len = parent_c_rev.f_index - c_rev.f_index
878
874
                        if line_len == 1:
879
875
                            group_key = None
880
876
                        else:
881
877
                            group_key = parent_c_rev.rev.branch_id
882
878
                        
883
879
                        dest.append(([parent_info],
884
880
                                     c_rev.f_index,
885
881
                                     parent_c_rev.f_index,
886
882
                                     group_key))
887
883
                
888
884
                # This may be a sprout. Add line to first visible child
889
885
                if c_rev.rev.merged_by is not None:
890
886
                    merged_by = self.revisions[c_rev.rev.merged_by]
891
887
                    if c_revisions[merged_by.index] is None and\
892
888
                       branch_revs[0].f_index == c_rev.f_index:
893
889
                        # The revision that merges this revision is not
894
890
                        # visible, and it is the first visible revision in
895
891
                        # the branch line. This is a sprout.
896
892
                        #
897
893
                        # XXX What if multiple merges with --force,
898
894
                        # aka octopus merge?
899
895
                        #
900
896
                        # Search until we find a descendant that is visible.
901
897
                        
902
898
                        while merged_by is not None and \
903
899
                              c_revisions[merged_by.index] is None:
904
900
                            if merged_by.merged_by is not None:
905
901
                                merged_by = self.revisions[merged_by.merged_by]
906
902
                            else:
907
903
                                merged_by = None
908
904
                        
909
905
                        if merged_by is not None:
910
906
                            # Ensure only one line to a descendant.
911
907
                            if (merged_by.index not in sprout_with_lines):
912
908
                                sprout_with_lines[merged_by.index] = True
913
909
                                parent = c_revisions[merged_by.index]
914
910
                                if parent is not None:
915
911
                                    if c_rev.f_index - parent.f_index == 1:
916
912
                                        col_index = None
917
913
                                    else:
918
914
                                        col_search_order = line_col_search_order(
919
915
                                            parent.col_index, c_rev.col_index)
920
916
                                        col_index = find_free_column(
921
917
                                            col_search_order,
922
918
                                            parent.f_index, c_rev.f_index)
923
919
                                    append_line(parent, c_rev, False,
924
920
                                                col_index)
925
921
            
926
922
            # Find a column for this branch.
927
923
            #
928
924
            # Find the col_index for the direct parent branch. This will
929
925
            # be the starting point when looking for a free column.
930
926
            
931
927
            append_branch_parent_lines(branch_rev_visible_parents_pre)
932
928
            
933
929
            if branch_id == ():
934
930
                start_col_index = 0
935
931
            else:
936
932
                start_col_index = 1
937
933
            
938
934
            if last_parent and last_parent[0].col_index is not None:
939
935
                parent_col_index = last_parent[1].col_index
940
936
                start_col_index = max(start_col_index, parent_col_index)
941
937
            
942
938
            start_col_index = max(start_col_index, merged_by_max_col_index)
943
939
            
944
940
            col_search_order = branch_line_col_search_order(start_col_index) 
945
941
            
946
942
            if last_parent:
947
943
                col_index = find_free_column(col_search_order,
948
944
                                             branch_revs[0].f_index,
949
945
                                             last_parent[1].f_index)
950
946
            else:
951
947
                col_index = find_free_column(col_search_order,
952
948
                                             branch_revs[0].f_index,
953
949
                                             branch_revs[-1].f_index)
954
950
            
955
951
            # Free column for this branch found. Set node for all
956
952
            # revision in this branch.
957
953
            for rev in branch_revs:
958
954
                rev.col_index = col_index
959
955
            
960
956
            append_line(branch_revs[0], branch_revs[-1], True, col_index)
961
957
            if last_parent:
962
958
                append_line(last_parent[0], last_parent[1],
963
959
                            last_parent[2], col_index)
964
960
            
965
961
            branch_rev_visible_parents_post.reverse()
966
962
            append_branch_parent_lines(branch_rev_visible_parents_post)
967
963
        
968
964
        # It has now been calculated which column a line must go into. Now
969
965
        # copy the lines in to computed_revisions.
970
966
        for (child, parent, line_col_index, direct) in lines:
971
967
            
972
968
            parent_color = parent.rev.color
973
969
            
974
970
            line_length = parent.f_index - child.f_index
975
971
            if line_length == 0:
976
972
                # Nothing to do
977
973
                pass
978
974
            elif line_length == 1:
979
975
                child.lines.append(
980
976
                    (child.col_index,
981
977
                     parent.col_index,
982
978
                     parent_color,
983
979
                     direct))
984
980
            else:
985
981
                # line from the child's column to the lines column
986
982
                child.lines.append(
987
983
                    (child.col_index,
988
984
                     line_col_index,
989
985
                     parent_color,
990
986
                     direct))
991
987
                # lines down the line's column
992
988
                for line_part_f_index in range(child.f_index + 1,
993
989
                                               parent.f_index - 1):
994
990
                    computed.filtered_revs[line_part_f_index].lines.append(
995
991
                        (line_col_index,
996
992
                         line_col_index,
997
993
                         parent_color,
998
994
                         direct))
999
995
                # line from the line's column to the parent's column
1000
996
                computed.filtered_revs[parent.f_index - 1].lines.append(
1001
997
                    (line_col_index,
1002
998
                     parent.col_index,
1003
999
                     parent_color,
1004
1000
                     direct))
1005
1001
        
1006
1002
        return computed
1007
1003
    
1008
1004
    def get_revid_branch_info(self, revid):
1009
1005
        """This returns a branch info whos branch contains the revision.
1010
1006
        
1011
1007
        If the revision exists more than one branch, it will only return the
1012
1008
        first branch info. """
1013
1009
        
1014
1010
        if revid in self.ghosts:
1015
1011
            raise GhostRevisionError(revid)
1016
1012
        
1017
1013
        if len(self.branches) == 1 or revid not in self.revid_branch_info:
1018
1014
            return self.branches[0]
1019
1015
        return self.revid_branch_info[revid]
1020
1016
    
1021
1017
    def get_revid_branch(self, revid):
1022
1018
        return self.get_revid_branch_info(revid).branch
1023
1019
    
1024
1020
    def get_revid_repo(self, revid):
1025
1021
        return self.get_revid_branch_info(revid).branch.repository
1026
1022
    
1027
1023
    def get_repo_revids(self, revids):
1028
1024
        """Returns list of tuple of (repo, revids)"""
1029
1025
        repo_revids = {}
1030
1026
        for repo in self.repos:
1031
1027
            repo_revids[repo.base] = []
1032
1028
        
1033
1029
        for local_repo_copy in self.local_repo_copies:
1034
1030
            for revid in self.repos[local_repo_copy].has_revisions(revids):
1035
1031
                revids.remove(revid)
1036
1032
                repo_revids[local_repo_copy].append(revid)
1037
1033
        
1038
1034
        for revid in revids:
1039
1035
            try:
1040
1036
                repo = self.get_revid_repo(revid)
1041
1037
            except GhostRevisionError:
1042
1038
                pass
1043
1039
            else:
1044
1040
                repo_revids[repo.base].append(revid)
1045
1041
        
1046
1042
        return [(repo, repo_revids[repo.base])
1047
1043
                for repo in self.repos]
1048
1044
    
1049
1045
    def load_revisions(self, revids):
1050
1046
        return_revisions = {}
1051
1047
        for repo, revids in self.get_repo_revids(revids):
1052
1048
            if revids:
1053
1049
                repo.lock_read()
1054
1050
                try:
1055
1051
                    self.update_ui()
1056
1052
                    for rev in repo.get_revisions(revids):
1057
1053
                        return_revisions[rev.revision_id] = rev
1058
1054
                finally:
1059
1055
                    repo.unlock()
1060
1056
        return return_revisions
1061
1057
1062
1058
1063
1059
def repo_is_local(repo):
1064
1060
    return isinstance(repo.bzrdir.transport, LocalTransport)
1065
1061
1066
1062
def group_overlapping(groups):
1067
1063
    """ Groups items with overlapping ranges together.
1068
1064
    
1069
1065
    :param groups: List of uncollapsed groups.
1070
1066
    :param group: (start of range, end of range, items in group)
1071
1067
    :return: List of collapsed groups.
1072
1068
    
1073
1069
    """
1074
1070
1075
1071
    has_change = True
1076
1072
    while has_change:
1077
1073
        has_change = False
1078
1074
        a = 0
1079
1075
        while a < len(groups):
1080
1076
            inner_has_change = False
1081
1077
            items_a, start_a, end_a, group_key_a = groups[a]
1082
1078
            if group_key_a is not None:
1083
1079
                b = a + 1
1084
1080
                while b < len(groups):
1085
1081
                    items_b, start_b, end_b, group_key_b = groups[b]
1086
1082
                    if (group_key_a == group_key_b and
1087
1083
                        range_overlaps(start_a, end_a, start_b, end_b)):
1088
1084
                            # overlaps. Merge b into a
1089
1085
                            items_a.extend(items_b)
1090
1086
                            start_a = min(start_a, start_b)
1091
1087
                            end_a = max(end_a, end_b)
1092
1088
                            del groups[b]
1093
1089
                            has_change = True
1094
1090
                            inner_has_change = True
1095
1091
                    else:
1096
1092
                        b += 1
1097
1093
                if inner_has_change:
1098
1094
                    groups[a] = (items_a, start_a, end_a, group_key_a)
1099
1095
            a += 1
1100
1096
    
1101
1097
    return groups
1102
1098
1103
1099
def range_overlaps (start_a, end_a, start_b, end_b):
1104
1100
    """Tests if two ranges overlap."""
1105
1101
    return (start_b < start_a < end_b or
1106
1102
            start_b < end_a < end_b or
1107
1103
            (start_a <= start_b and end_a >= end_b))
1108
1104
1109
1105
1110
1106
class PendingMergesGraphVizLoader(GraphVizLoader):
1111
1107
    """GraphVizLoader that only loads pending merges.
1112
1108
    
1113
1109
    As only the pending merges are passed to merge_sort, the revno
1114
1110
    are incorrect, and should be ignored.
1115
1111
    
1116
1112
    Only works on a single branch.
1117
1113
    
1118
1114
    """
1119
1115
    
1120
1116
    def load_graph_parents(self):
1121
1117
        if not len(self.branches) == 1 or not len(self.repos) == 1:
1122
1118
            AssertionError("load_graph_pending_merges should only be called \
1123
1119
                           when 1 branch and repo has been opened.")
1124
1120
        
1125
1121
        bi = self.branches[0]
1126
1122
        if bi.tree is None:
1127
1123
            AssertionError("PendingMergesGraphVizLoader must have a working "
1128
1124
                           "tree.")
1129
1125
        
1130
1126
        self.graph = bi.branch.repository.get_graph()
1131
1127
        tree_heads = bi.tree.get_parent_ids()
1132
1128
        other_revisions = [tree_heads[0], ]
1133
1129
        self.update_ui()
1134
1130
        
1135
1131
        self.append_head_info('root:', bi, None)
1136
1132
        pending_merges = []
1137
1133
        for head in tree_heads[1:]:
1138
1134
            self.append_head_info(head, bi, None)
1139
1135
            pending_merges.extend(
1140
1136
                self.graph.find_unique_ancestors(head, other_revisions))
1141
1137
            other_revisions.append(head)
1142
1138
            self.update_ui()
1143
1139
        
1144
1140
        graph_parents = self.graph.get_parent_map(pending_merges)
1145
1141
        graph_parents["root:"] = ()
1146
1142
        self.update_ui()
1147
1143
        
1148
1144
        for (revid, parents) in graph_parents.items():
1149
1145
            new_parents = []
1150
1146
            for index, parent in enumerate(parents):
1151
1147
                if parent in graph_parents:
1152
1148
                    new_parents.append(parent)
1153
1149
                elif index == 0:
1154
1150
                    new_parents.append("root:")
1155
1151
            graph_parents[revid] = tuple(new_parents)
1156
1152
        
1157
1153
        return ["root:", ] + tree_heads[1:], graph_parents.items()
1158
1154
1159
1155
1160
1156
class WithWorkingTreeGraphVizLoader(GraphVizLoader):
1161
1157
    """
1162
1158
    GraphVizLoader that shows uncommitted working tree changes as a node
1163
1159
    in the graph, as if it was already committed.
1164
1160
    """
1165
1161
    
1166
1162
    def tree_revid(self, tree):
1167
1163
        return CURRENT_REVISION + tree.basedir.encode('unicode-escape')
1168
1164
    
1169
1165
    def load(self):
1170
1166
        self.working_trees = {}
1171
1167
        for bi in self.branches:
1172
1168
            if not bi.tree is None:
1173
1169
                self.working_trees[self.tree_revid(bi.tree)] = bi.tree
1174
1170
        
1175
1171
        super(WithWorkingTreeGraphVizLoader, self).load()
1176
1172
    
1177
1173
    def load_branch_heads(self, bi):
1178
1174
        # returns load_heads, sort_heads and also calls append_head_info.
1179
1175
        #
1180
1176
        # == For branch with tree ==
1181
1177
        # Graph                   | load_heads | sort_heads | append_head_info
1182
1178
        # wt                      | No         | Yes        | Yes   
1183
1179
        # | \                     |            |            |
1184
1180
        # | 1.1.2 pending merge   | Yes        | No         | Yes
1185
1181
        # 2 |     basis rev       | Yes        | No         | Yes
1186
1182
        #
1187
1183
        # == For branch with tree not up to date ==
1188
1184
        # Graph                   | load_heads | sort_heads | append_head_info
1189
1185
        #   wt                    | No         | Yes        | Yes   
1190
1186
        #   | \                   |            |            |
1191
1187
        #   | 1.1.2 pending merge | Yes        | No         | Yes
1192
1188
        # 3/  |     branch tip    | Yes        | Yes        | Yes      
1193
1189
        # 2   |     basis rev     | Yes        | No         | No
1194
1190
        #
1195
1191
        # == For branch without tree ==
1196
1192
        # branch tip              | Yes        | head       | yes
1197
1193
        
1198
1194
        load_heads = []
1199
1195
        sort_heads = []
1200
1196
        extra_parents = []
1201
1197
        
1202
1198
        if len(self.branches) > 0:
1203
1199
            label = bi.label
1204
1200
        else:
1205
1201
            label = None
1206
1202
        
1207
1203
        branch_last_revision = bi.branch.last_revision()
1208
1204
        self.append_head_info(branch_last_revision, bi, bi.label)
1209
1205
        load_heads.append(branch_last_revision)
1210
1206
        self.update_ui()
1211
1207
        
1212
1208
        if bi.tree:
1213
1209
            wt_revid = self.tree_revid(bi.tree)
1214
1210
            if label:
1215
1211
                wt_label = "%s - Working Tree" % label
1216
1212
            else:
1217
1213
                wt_label = "Working Tree"
1218
1214
            self.append_head_info(wt_revid, bi, wt_label)
1219
1215
            parent_ids = bi.tree.get_parent_ids()
1220
1216
            
1221
1217
            extra_parents.append((wt_revid, parent_ids))
1222
1218
            load_heads.extend(parent_ids)
1223
1219
            
1224
1220
            if parent_ids:
1225
1221
                # first parent is last revision of the tree
1226
1222
                if parent_ids[0] != branch_last_revision:
1227
1223
                    # tree is not up to date.
1228
1224
                    sort_heads.append(branch_last_revision)
1229
1225
                
1230
1226
                # other parents are pending merges
1231
1227
                for revid in parent_ids[1:]:
1232
1228
                    if label:
1233
1229
                        pm_label = "%s - Pending Merge" % label
1234
1230
                    else:
1235
1231
                        pm_label = "Pending Merge"
1236
1232
                    self.append_head_info(revid, bi, pm_label)
1237
1233
            
1238
1234
            sort_heads.append(wt_revid)
1239
1235
            self.update_ui()
1240
1236
        else:
1241
1237
            sort_heads.append(branch_last_revision)
1242
1238
        
1243
1239
        return load_heads, sort_heads, extra_parents
1244
1240
1245
1241
1246
1242
class GraphVizFilterState(object):
1247
1243
    """
1248
1244
    Records the state of which branch lines are expanded, and what filters
1249
1245
    are applied.
1250
1246
    """
1251
1247
    
1252
1248
    def __init__(self, graph_viz, filter_changed_callback=None):
1253
1249
        self.graph_viz = graph_viz
1254
1250
        self.filter_changed_callback = filter_changed_callback
1255
1251
        
1256
1252
        self.branch_line_state = {}
1257
1253
        "If a branch_id is in this dict, it is visible. The value of the dict "
1258
1254
        "indicates which branches expanded this branch."
1259
1255
        
1260
1256
        for revid in self.graph_viz.revid_head_info:
1261
1257
            rev = self.graph_viz.revid_rev[revid]
1262
1258
            self.branch_line_state[rev.branch_id] = None
1263
1259
        
1264
1260
        self.filters = []
1265
1261
        
1266
1262
        # This keeps a cache of the filter state so that when one of the
1267
1263
        # filters notifies us of a change, we can check if anything did change.
1268
1264
        
1269
1265
        self.filter_cache = [None for rev in self.graph_viz.revisions]
1270
1266
    
1271
1267
    def get_filtered_revisions(self):
1272
1268
        if self.graph_viz.no_graph:
1273
1269
            rev_whos_branch_is_visible = self.graph_viz.revisions
1274
1270
        else:
1275
1271
            rev_whos_branch_is_visible = []
1276
1272
            for branch_id in self.branch_line_state.iterkeys():
1277
1273
                try:
1278
1274
                    branch_line = self.graph_viz.branch_lines[branch_id]
1279
1275
                except KeyError:
1280
1276
                    continue
1281
1277
                rev_whos_branch_is_visible.extend(branch_line.revs)
1282
1278
            rev_whos_branch_is_visible.sort(key=lambda rev: rev.index)
1283
1279
        
1284
1280
        visible = self.get_revision_visible_if_branch_visible
1285
1281
        return (rev for rev in rev_whos_branch_is_visible if visible(rev))
1286
1282
    
1287
1283
    def get_revision_visible_if_branch_visible(self, rev):
1288
1284
        rev_filter_cache = self.filter_cache[rev.index]
1289
1285
        if rev_filter_cache is None:
1290
1286
            rev_filter_cache = \
1291
1287
                self._get_revision_visible_if_branch_visible(rev)
1292
1288
            self.filter_cache[rev.index] = rev_filter_cache
1293
1289
        return rev_filter_cache
1294
1290
    
1295
1291
    def _get_revision_visible_if_branch_visible(self, rev):
1296
1292
        filters_value = True
1297
1293
        for filter in self.filters:
1298
1294
            if not filter.get_revision_visible(rev):
1299
1295
                filters_value = False
1300
1296
                break
1301
1297
        if filters_value:
1302
1298
            return True
1303
1299
        
1304
1300
        if not self.graph_viz.no_graph:
1305
1301
            for merged_index in rev.merges:
1306
1302
                merged_rev = self.graph_viz.revisions[merged_index]
1307
1303
                if self.get_revision_visible_if_branch_visible(merged_rev):
1308
1304
                    return True
1309
1305
        
1310
1306
        return False
1311
1307
    
1312
1308
    def filter_changed(self, revs=None, last_call=True):
1313
1309
        if revs is None:
1314
1310
            self.filter_cache = [None for rev in self.graph_viz.revisions]
1315
1311
            if self.filter_changed_callback:
1316
1312
                self.filter_changed_callback()
1317
1313
        else:
1318
1314
            pending_revs = revs
1319
1315
            processed_revs = set()
1320
1316
            prev_cached_revs = []
1321
1317
            while pending_revs:
1322
1318
                rev = pending_revs.pop(0)
1323
1319
                if rev in processed_revs:
1324
1320
                    continue
1325
1321
                processed_revs.add(rev)
1326
1322
                
1327
1323
                rev_filter_cache = self.filter_cache[rev.index]
1328
1324
                
1329
1325
                if rev_filter_cache is not None:
1330
1326
                    prev_cached_revs.append((rev, rev_filter_cache))
1331
1327
                self.filter_cache[rev.index] = None
1332
1328
                
1333
1329
                if not self.graph_viz.no_graph:
1334
1330
                    if rev.merged_by is not None:
1335
1331
                        pending_revs.append(
1336
1332
                            self.graph_viz.revisions[rev.merged_by])
1337
1333
           
1338
1334
            # Check if any visibilities have changes. If they have, call
1339
1335
            # filter_changed_callback
1340
1336
            for rev, prev_visible in prev_cached_revs:
1341
1337
                visible = self.get_revision_visible_if_branch_visible(rev)
1342
1338
                if visible != prev_visible:
1343
1339
                    if self.filter_changed_callback:
1344
1340
                        self.filter_changed_callback()
1345
1341
                    break
1346
1342
    
1347
1343
    def ensure_rev_visible(self, rev):
1348
1344
        if self.graph_viz.no_graph:
1349
1345
            return False
1350
1346
        
1351
1347
        branch_id = rev.branch_id
1352
1348
        if branch_id not in self.branch_line_state:
1353
1349
            self.branch_line_state[branch_id] = None
1354
1350
            if self.filter_changed_callback:
1355
1351
                self.filter_changed_callback()
1356
1352
            return True
1357
1353
        return False
1358
1354
    
1359
1355
    def collapse_expand_rev(self, c_rev, in_place_mod=True):
1360
1356
        if in_place_mod:
1361
1357
            branch_line_state = self.branch_line_state
1362
1358
        else:
1363
1359
            # create a copy of the state dict
1364
1360
            branch_line_state = dict(self.branch_line_state)
1365
1361
1366
1362
        if c_rev is None:
1367
1363
            return False
1368
1364
        visible = not c_rev.twisty_state
1369
1365
        branch_ids = zip(
1370
1366
            c_rev.twisty_expands_branch_ids,
1371
1367
            [c_rev.rev.branch_id] * len(c_rev.twisty_expands_branch_ids))
1372
1368
        
1373
1369
        seen_branch_ids = set(branch_id
1374
1370
                              for branch_id, expanded_by in branch_ids)
1375
1371
        has_change = False
1376
1372
        while branch_ids:
1377
1373
            branch_id, expanded_by = branch_ids.pop()
1378
1374
            if (branch_id in branch_line_state) != visible:
1379
1375
                has_change = True
1380
1376
            if not visible:
1381
1377
                del branch_line_state[branch_id]
1382
1378
                parents = self.graph_viz.branch_lines[branch_id].merges
1383
1379
                for parent_branch_id in parents:
1384
1380
                    parent_visible = parent_branch_id in branch_line_state
1385
1381
                    if (not parent_visible or 
1386
1382
                        parent_branch_id in seen_branch_ids):
1387
1383
                        continue
1388
1384
                    
1389
1385
                    if branch_line_state[parent_branch_id] == branch_id:
1390
1386
                        # This branch expanded the parent branch, so we must
1391
1387
                        # collapse it.
1392
1388
                        branch_ids.append((parent_branch_id, branch_id))
1393
1389
                        seen_branch_ids.add(parent_branch_id)
1394
1390
                    else:
1395
1391
                        # Check if this parent has any other visible branches
1396
1392
                        # that merge it.
1397
1393
                        has_visible = False
1398
1394
                        parent = self.graph_viz.branch_lines[parent_branch_id]
1399
1395
                        for merged_by_branch_id in parent.merged_by:
1400
1396
                            if merged_by_branch_id in branch_line_state:
1401
1397
                                has_visible = True
1402
1398
                                break
1403
1399
                        if not has_visible:
1404
1400
                            branch_ids.append((parent_branch_id, branch_id))
1405
1401
                            seen_branch_ids.add(parent_branch_id)
1406
1402
            else:
1407
1403
                branch_line_state[branch_id] = expanded_by
1408
1404
        if has_change and self.filter_changed_callback and in_place_mod:
1409
1405
            self.filter_changed_callback()
1410
1406
        return branch_line_state
1411
1407
    
1412
1408
    def expand_all_branch_lines(self):
1413
1409
        for branch_id in self.graph_viz.branch_lines.keys():
1414
1410
            if branch_id not in self.branch_line_state:
1415
1411
                self.branch_line_state[branch_id] = None
1416
1412
    
1417
1413
1418
1414
class FileIdFilter (object):
1419
1415
    """
1420
1416
    Filter that only shows revisions that modify one of the specified files.
1421
1417
    """
1422
1418
    
1423
1419
    def __init__(self, graph_viz, filter_changed_callback, file_ids):
1424
1420
        self.graph_viz = graph_viz
1425
1421
        self.filter_changed_callback = filter_changed_callback
1426
1422
        self.file_ids = file_ids
1427
1423
        self.has_dir = False
1428
1424
        self.filter_file_id = [False for rev in self.graph_viz.revisions]
1429
1425
        
1430
1426
        # don't filter working tree nodes
1431
1427
        if isinstance(self.graph_viz, WithWorkingTreeGraphVizLoader):
1432
1428
            for wt_revid in self.graph_viz.working_trees.iterkeys():
1433
1429
                try:
1434
1430
                    rev_index = self.graph_viz.revid_rev[wt_revid].index
1435
1431
                    self.filter_file_id[rev_index] = True
1436
1432
                except KeyError:
1437
1433
                    pass
1438
1434
        
1439
1435
    
1440
1436
    def uses_inventory(self):
1441
1437
        return self.has_dir
1442
1438
    
1443
1439
    def load(self, revids=None):
1444
1440
        """Load which revisions affect the file_ids"""
1445
1441
        if self.file_ids:
1446
1442
            self.graph_viz.throbber_show()
1447
1443
            
1448
1444
            for bi in self.graph_viz.branches:
1449
1445
                tree = bi.tree
1450
1446
                if tree is None:
1451
1447
                    tree = bi.branch.basis_tree()
1452
1448
                
1453
1449
                tree.lock_read()
1454
1450
                try:
1455
1451
                    for file_id in self.file_ids:
1456
1452
                        if tree.kind(file_id) in ('directory',
1457
1453
                                                  'tree-reference'):
1458
1454
                            self.has_dir = True
1459
1455
                            break
1460
1456
                    if self.has_dir:
1461
1457
                        break
1462
1458
                finally:
1463
1459
                    tree.unlock()
1464
1460
            
1465
1461
            if revids is None:
1466
1462
                revids = [rev.revid for rev in self.graph_viz.revisions]
1467
1463
            
1468
1464
            for repo, revids in self.graph_viz.get_repo_revids(revids):
1469
1465
                if self.uses_inventory():
1470
1466
                    chunk_size = 200
1471
1467
                else:
1472
1468
                    chunk_size = 500
1473
1469
                
1474
1470
                for start in xrange(0, len(revids), chunk_size):
1475
1471
                    self.load_filter_file_id_chunk(repo, 
1476
1472
                            revids[start:start + chunk_size])
1477
1473
            
1478
1474
            self.load_filter_file_id_chunk_finished()
1479
1475
    
1480
1476
    def load_filter_file_id_chunk(self, repo, revids):
1481
1477
        def check_text_keys(text_keys):
1482
1478
            changed_revs = []
1483
1479
            for file_id, revid in repo.texts.get_parent_map(text_keys):
1484
1480
                rev = self.graph_viz.revid_rev[revid]
1485
1481
                self.filter_file_id[rev.index] = True
1486
1482
                changed_revs.append(rev)
1487
1483
            
1488
1484
            self.graph_viz.update_ui()
1489
1485
            self.filter_changed_callback(changed_revs, False)
1490
1486
            self.graph_viz.update_ui()
1491
1487
        
1492
1488
        repo.lock_read()
1493
1489
        try:
1494
1490
            if not self.uses_inventory():
1495
1491
                text_keys = [(file_id, revid) 
1496
1492
                                for revid in revids
1497
1493
                                for file_id in self.file_ids]
1498
1494
                check_text_keys(text_keys)
1499
1495
            else:
1500
1496
                text_keys = []
1501
1497
                # We have to load the inventory for each revisions, to find
1502
1498
                # the children of any directories.
1503
1499
                for inv, revid in izip(repo.iter_inventories(revids), revids):
1504
1500
                    entries = inv.iter_entries_by_dir(
1505
1501
                                         specific_file_ids=self.file_ids)
1506
1502
                    for path, entry in entries:
1507
1503
                        text_keys.append((entry.file_id, revid))
1508
1504
                        if entry.kind == "directory":
1509
1505
                            sub_entries = inv.iter_entries(from_dir=entry)
1510
1506
                            for rc_path, rc_entry in sub_entries:
1511
1507
                                text_keys.append((rc_entry.file_id, revid))
1512
1508
                    
1513
1509
                    self.graph_viz.update_ui()
1514
1510
                
1515
1511
                check_text_keys(text_keys)
1516
1512
        finally:
1517
1513
            repo.unlock()
1518
1514
1519
1515
    def load_filter_file_id_chunk_finished(self):
1520
1516
        self.filter_changed_callback([], True)
1521
1517
        self.graph_viz.throbber_hide()
1522
1518
    
1523
1519
    def get_revision_visible(self, rev):
1524
1520
        return self.filter_file_id[rev.index]
1525
1521
1526
1522
1527
1523
class WorkingTreeHasChangeFilter(object):
1528
1524
    """
1529
1525
    Filter out working trees that don't have any changes.
1530
1526
    """
1531
1527
    
1532
1528
    def __init__(self, graph_viz, filter_changed_callback, file_ids):
1533
1529
        self.graph_viz = graph_viz
1534
1530
        self.file_ids = file_ids
1535
1531
        if not isinstance(graph_viz, WithWorkingTreeGraphVizLoader):
1536
1532
            raise TypeError('graph_viz expected to be a '
1537
1533
                            'WithWorkingTreeGraphVizLoader')
1538
1534
        self.filter_changed_callback = filter_changed_callback
1539
1535
        self.tree_revids_with_changes = set()
1540
1536
    
1541
1537
    def load(self):
1542
1538
        """Load if the working trees have changes."""
1543
1539
        self.tree_revids_with_changes = set()
1544
1540
        self.graph_viz.throbber_show()
1545
1541
        try:
1546
1542
            for wt_revid, tree in self.graph_viz.working_trees.iteritems():
1547
1543
                if self.has_changes(tree):
1548
1544
                    self.tree_revids_with_changes.add(wt_revid)
1549
1545
                rev = self.graph_viz.revid_rev[wt_revid]
1550
1546
                self.filter_changed_callback([rev], False)
1551
1547
            self.filter_changed_callback([], True) 
1552
1548
        finally:
1553
1549
            self.graph_viz.throbber_hide()
1554
1550
1555
1551
    def has_changes(self, tree):
1556
1552
        """Quickly check that the tree contains at least one commitable change.
1557
1553
1558
1554
        :param _from_tree: tree to compare against to find changes (default to
1559
1555
            the basis tree and is intended to be used by tests).
1560
1556
1561
1557
        :return: True if a change is found. False otherwise
1562
1558
        """
1563
1559
        tree.lock_read()
1564
1560
        try:
1565
1561
            # Copied from mutabletree, cause we need file_ids too.
1566
1562
            # Check pending merges
1567
1563
            if len(tree.get_parent_ids()) > 1:
1568
1564
                return True
1569
1565
            from_tree = tree.basis_tree()
1570
1566
            
1571
1567
            specific_files = None
1572
1568
            if self.file_ids:
1573
1569
                specific_files = [tree.id2path(file_id)
1574
1570
                                  for file_id in self.file_ids]
1575
1571
            
1576
1572
            changes = tree.iter_changes(from_tree,
1577
1573
                                        specific_files=specific_files)
1578
1574
            try:
1579
1575
                change = changes.next()
1580
1576
                # Exclude root (talk about black magic... --vila 20090629)
1581
1577
                if change[4] == (None, None):
1582
1578
                    change = changes.next()
1583
1579
                return True
1584
1580
            except StopIteration:
1585
1581
                # No changes
1586
1582
                return False
1587
1583
        finally:
1588
1584
            tree.unlock()
1589
1585
    
1590
1586
    def get_revision_visible(self, rev):
1591
1587
        if rev.revid.startswith(CURRENT_REVISION):
1592
1588
            return rev.revid in self.tree_revids_with_changes
1593
1589
        else:
1594
1590
            return True
1595
1591
1596
1592
1597
1593
class ComputedRevisionData(object):
1598
1594
    """Container for computed layout data for a revision.
1599
1595
    
1600
1596
    :ivar rev: Reference to RevisionData. Use to get revno, revid, color and
1601
1597
        others.
1602
1598
    :ivar f_index: Index in `ComputedGraphViz.filtered_revs`.
1603
1599
    :ivar col_index: Column index to place node for revision in.
1604
1600
    :ivar lines: Lines that need to be drawn from from this revision's line to
1605
1601
        the next revision's line. Note that not all these lines relate to this
1606
1602
        revision, but be a part of a longer line that is passing this revision.
1607
1603
        
1608
1604
        Each line is a tuple of `(end col_index, start col_index, color,
1609
1605
        direct)`.
1610
1606
        
1611
1607
        If direct is False, it indicates that this line represents an
1612
1608
        ancestry, with revisions that are filtered. This should be shown as
1613
1609
        a dotted line.
1614
1610
        
1615
1611
    :ivar branch_labels: Labels for branch tips.
1616
1612
    :ivar twisty_state: State of the revision:
1617
1613
        
1618
1614
        * None: No twisty.
1619
1615
        * True: There are branch lines that this revision merges that can
1620
1616
          expanded. Show a '+'.
1621
1617
        * False: All branches that this revision merges are already expanded.
1622
1618
          Show a '-'.
1623
1619
    :ivar twisty_expands_branch_ids: Branch lines that will be expanded if the
1624
1620
        twisty is clicked.
1625
1621
    """
1626
1622
    
1627
1623
    # Instance of this object are typically named "c_rev".    
1628
1624
    __slots__ = ['rev', 'f_index', 'lines', 'col_index', 'branch_labels',
1629
1625
                 'twisty_state', 'twisty_expands_branch_ids']
1630
1626
    
1631
1627
    def __init__(self, rev):
1632
1628
        self.rev = rev
1633
1629
        self.lines = []
1634
1630
        self.col_index = None
1635
1631
        self.twisty_state = None
1636
1632
        self.twisty_expands_branch_ids = []
1637
1633
        self.branch_labels = []
1638
1634
1639
1635
1640
1636
class ComputedGraphViz(object):
1641
1637
    """Computed layout data for a graph.
1642
1638
    
1643
1639
    :ivar graph_viz: Reference to parent `GraphVizLoader`. 
1644
1640
    :ivar filtered_revs: List `ComputedRevisionData`. Only visible revisions
1645
1641
        are included.
1646
1642
    :ivar revisions: List `ComputedRevisionData`. Revision that are not
1647
1643
        visible are None.
1648
1644
    """
1649
1645
    def __init__(self, graph_viz):
1650
1646
        self.graph_viz = graph_viz
1651
1647
        self.filtered_revs = []
1652
1648
        self.revisions = [None for i in xrange(len(graph_viz.revisions))]
1653
0
1649
1654
=== modified file 'bzrlib/tests/__init__.py'
1655
--- bzrlib/tests/__init__.py	2010-10-18 17:06:37 +0000
1656
+++ bzrlib/tests/__init__.py	2010-11-18 10:15:44 +0000
1657
@@ -3739,6 +3739,7 @@
1658
3739
        'bzrlib.tests.test_lockable_files',
3739
        'bzrlib.tests.test_lockable_files',
1659
3740
        'bzrlib.tests.test_lockdir',
3740
        'bzrlib.tests.test_lockdir',
1660
3741
        'bzrlib.tests.test_log',
3741
        'bzrlib.tests.test_log',
1661
3742
        'bzrlib.tests.test_loggraphviz',
1662
3742
        'bzrlib.tests.test_lru_cache',
3743
        'bzrlib.tests.test_lru_cache',
1663
3743
        'bzrlib.tests.test_lsprof',
3744
        'bzrlib.tests.test_lsprof',
1664
3744
        'bzrlib.tests.test_mail_client',
3745
        'bzrlib.tests.test_mail_client',
1665
3745
3746
1666
=== added file 'bzrlib/tests/test_loggraphviz.py'
1667
--- bzrlib/tests/test_loggraphviz.py	1970-01-01 00:00:00 +0000
1668
+++ bzrlib/tests/test_loggraphviz.py	2010-11-18 10:15:44 +0000
1669
@@ -0,0 +1,1153 @@
1670
1
# -*- coding: utf-8 -*-
1671
2
# Copyright (C) 2010 Canonical Ltd
1672
3
#
1673
4
# This program is free software; you can redistribute it and/or
1674
5
# modify it under the terms of the GNU General Public License
1675
6
# as published by the Free Software Foundation; either version 2
1676
7
# of the License, or (at your option) any later version.
1677
8
#
1678
9
# This program is distributed in the hope that it will be useful,
1679
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1680
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1681
12
# GNU General Public License for more details.
1682
13
#
1683
14
# You should have received a copy of the GNU General Public License
1684
15
# along with this program; if not, write to the Free Software
1685
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
1686
17
1687
18
from bzrlib.tests import TestCase, TestCaseWithTransport
1688
19
from StringIO import StringIO
1689
20
1690
21
from bzrlib import loggraphviz
1691
22
from bzrlib.revision import NULL_REVISION
1692
23
1693
24
# TODO:
1694
25
# Tag loading
1695
26
# Branch labels + Filtering
1696
27
# Ghosts
1697
28
# file_ids filtering
1698
29
1699
30
class TestLogGraphVizMixin(object):
1700
31
    def computed_to_list(self, computed, branch_labels=False):
1701
32
        if not branch_labels:
1702
33
            item = lambda c_rev: (c_rev.rev.revid,
1703
34
                                  c_rev.col_index,
1704
35
                                  c_rev.twisty_state,
1705
36
                                  sorted(c_rev.lines),)
1706
37
        else:
1707
38
            item = lambda c_rev: (c_rev.rev.revid,
1708
39
                                  c_rev.col_index,
1709
40
                                  c_rev.twisty_state,
1710
41
                                  sorted(c_rev.lines),
1711
42
                                  [label for bi, label in c_rev.branch_labels])
1712
43
        
1713
44
        return [item(c_rev) for c_rev in computed.filtered_revs]
1714
45
    
1715
46
    def assertComputed(self, expected_list, computed, branch_labels=False):
1716
47
        computed_list = self.computed_to_list(computed, branch_labels)
1717
48
        if not expected_list == computed_list:
1718
49
            raise AssertionError(
1719
50
                "not equal: \nexpected_list = \n%scomputed_list = \n%s"
1720
51
                % (format_graph_lines(expected_list, use_unicode=True),
1721
52
                   format_graph_lines(computed_list, use_unicode=True),))
1722
53
    
1723
54
1724
55
class TestLogGraphVizWithBranches(TestCaseWithTransport, TestLogGraphVizMixin):
1725
56
1726
57
    def test_no_commits(self):
1727
58
        br = self.make_branch('.')
1728
59
        
1729
60
        bi = loggraphviz.BranchInfo('', None, br)
1730
61
        gv = loggraphviz.GraphVizLoader([bi], bi, False)
1731
62
        gv.load()
1732
63
        
1733
64
        self.assertEqual(len(gv.revisions), 0)
1734
65
        
1735
66
        state = loggraphviz.GraphVizFilterState(gv)
1736
67
        computed = gv.compute_viz(state)
1737
68
        self.assertEqual(len(computed.revisions), 0)
1738
69
1739
70
    def make_banches_for_tips_date_sorted(self):
1740
71
        builder = self.make_branch_builder('trunk')
1741
72
        builder.start_series()
1742
73
        builder.build_snapshot('rev-a', None, [
1743
74
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1744
75
        builder.build_snapshot('rev-old', ['rev-a'], [])
1745
76
        builder.build_snapshot('rev-new', ['rev-a'], [])
1746
77
        builder.build_snapshot('rev-trunk', ['rev-a'], [])
1747
78
        builder.finish_series()
1748
79
        
1749
80
        trunk = builder.get_branch()
1750
81
        #trunk.set_last_revision('rev-trunk')
1751
82
        
1752
83
        old = trunk.bzrdir.sprout('../old', revision_id='rev-old').open_branch()
1753
84
        
1754
85
        new = trunk.bzrdir.sprout('../new', revision_id='rev-new').open_branch()
1755
86
        
1756
87
        return trunk, old, new
1757
88
1758
89
    def test_branch_tips_date_sorted(self):
1759
90
        trunk, old, new = self.make_banches_for_tips_date_sorted()
1760
91
        
1761
92
        trunk_bi = loggraphviz.BranchInfo('trunk', None, trunk)
1762
93
        gv = loggraphviz.GraphVizLoader(
1763
94
            [trunk_bi,
1764
95
             loggraphviz.BranchInfo('old', None, old),
1765
96
             loggraphviz.BranchInfo('new', None, new),],
1766
97
            trunk_bi, False)
1767
98
        gv.load()
1768
99
        
1769
100
        state = loggraphviz.GraphVizFilterState(gv)
1770
101
        computed = gv.compute_viz(state)
1771
102
        
1772
103
        self.assertComputed(
1773
104
            [('rev-new', 2, None, [(2, 2, 0, True)])                 , #     ○ 
1774
105
                                                                       #     │ 
1775
106
             ('rev-old', 1, None, [(1, 1, 0, True), (2, 2, 0, True)]), #   ○ │ 
1776
107
                                                                       #   │ │ 
1777
108
             ('rev-trunk', 0, None, [(0, 0, 0, True), (1, 0, 0, True), # ○ │ │ 
1778
109
                                     (2, 0, 0, True)]),                # ├─╯─╯ 
1779
110
             ('rev-a', 0, None, [])                                  ],# ○ 
1780
111
            computed)
1781
112
    
1782
113
    def test_branch_tips_date_sorted_with_working_tree_provider(self):
1783
114
        trunk, old, new = self.make_banches_for_tips_date_sorted()
1784
115
        trunk_tree = trunk.bzrdir.create_workingtree()
1785
116
        old_tree = old.bzrdir.open_workingtree()
1786
117
        new_tree = new.bzrdir.open_workingtree()
1787
118
        
1788
119
        trunk_bi = loggraphviz.BranchInfo('trunk', trunk_tree, trunk)
1789
120
        gv = loggraphviz.WithWorkingTreeGraphVizLoader(
1790
121
            [trunk_bi,
1791
122
             loggraphviz.BranchInfo('old', old_tree, old),
1792
123
             loggraphviz.BranchInfo('new', new_tree, new),],
1793
124
            trunk_bi, False)
1794
125
        gv.load()
1795
126
        
1796
127
        state = loggraphviz.GraphVizFilterState(gv)
1797
128
        computed = gv.compute_viz(state)
1798
129
        
1799
130
        self.assertComputed(
1800
131
            [(gv.tree_revid(new_tree), 2, None, [(2, 2, 3, True)]),    #     ○ 
1801
132
                                                                       #     │ 
1802
133
             ('rev-new', 2, None, [(2, 2, 0, True)]),                  #     ○ 
1803
134
                                                                       #     │ 
1804
135
             (gv.tree_revid(old_tree), 1, None, [(1, 1, 2, True),      #   ○ │ 
1805
136
                                                 (2, 2, 0, True)]),    #   │ │
1806
137
             ('rev-old', 1, None, [(1, 1, 0, True), (2, 2, 0, True)]), #   ○ │ 
1807
138
                                                                       #   │ │ 
1808
139
             (gv.tree_revid(trunk_tree), 0, None, [                    # ○ │ │ 
1809
140
                (0, 0, 0, True), (1, 1, 0, True), (2, 2, 0, True)]),   # │ │ │ 
1810
141
             ('rev-trunk', 0, None, [(0, 0, 0, True), (1, 0, 0, True), # ○ │ │ 
1811
142
                                     (2, 0, 0, True)]),                # ├─╯─╯
1812
143
             ('rev-a', 0, None, [])],                                  # ○ 
1813
144
            computed)
1814
145
 
1815
146
    
1816
147
    def make_tree_with_pending_merge(self, path):
1817
148
        builder = self.make_branch_builder('branch')
1818
149
        builder.start_series()
1819
150
        builder.build_snapshot('rev-a', None, [
1820
151
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1821
152
        builder.build_snapshot('rev-b', ['rev-a'], [])
1822
153
        builder.finish_series()
1823
154
        
1824
155
        branch = builder.get_branch()
1825
156
        branch.set_last_revision_info(1, 'rev-a') # go back to rev-a
1826
157
        tree = branch.bzrdir.create_workingtree()
1827
158
        tree.merge_from_branch(branch, to_revision='rev-b')
1828
159
        
1829
160
        return tree
1830
161
    
1831
162
    def make_tree_not_up_to_date(self, path):
1832
163
        builder = self.make_branch_builder('branch')
1833
164
        builder.start_series()
1834
165
        builder.build_snapshot('rev-a', None, [
1835
166
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1836
167
        builder.build_snapshot('rev-b', ['rev-a'], [])
1837
168
        builder.finish_series()
1838
169
        
1839
170
        branch = builder.get_branch()
1840
171
        tree = branch.bzrdir.create_workingtree()
1841
172
        tree.update(revision='rev-a')
1842
173
        return tree
1843
174
    
1844
175
    def test_pending_merge(self):
1845
176
        tree = self.make_tree_with_pending_merge('branch')
1846
177
        
1847
178
        bi = loggraphviz.BranchInfo(None, tree, tree.branch)
1848
179
        gv = loggraphviz.GraphVizLoader([bi], bi, False)
1849
180
        gv.load()
1850
181
        
1851
182
        state = loggraphviz.GraphVizFilterState(gv)
1852
183
        computed = gv.compute_viz(state)
1853
184
        
1854
185
        self.assertComputed(
1855
186
            [('rev-b', 1, None, [(1, 0, 0, True)], ['Pending Merge']), #   ○ 
1856
187
                                                                       # ╭─╯ 
1857
188
             ('rev-a', 0, None, [], [None])                          ],# ○ 
1858
189
            computed, branch_labels=True)
1859
190
1860
191
    def test_out_of_date_wt(self):
1861
192
        tree = self.make_tree_not_up_to_date('branch')
1862
193
        bi = loggraphviz.BranchInfo(None, tree, tree.branch)
1863
194
        gv = loggraphviz.GraphVizLoader([bi], bi, False)
1864
195
        gv.load()
1865
196
        
1866
197
        state = loggraphviz.GraphVizFilterState(gv)
1867
198
        computed = gv.compute_viz(state)
1868
199
        
1869
200
        self.assertComputed(
1870
201
            [('rev-b', 0, None, [(0, 0, 0, True)], [None]), # ○ 
1871
202
                                                            # │ 
1872
203
             ('rev-a', 0, None, [], ['Working Tree'])     ],# ○
1873
204
            computed, branch_labels=True)
1874
205
    
1875
206
    def test_with_working_tree_provider(self):
1876
207
        tree = self.make_tree_with_pending_merge('branch')
1877
208
        
1878
209
        bi = loggraphviz.BranchInfo('branch', tree, tree.branch)
1879
210
        gv = loggraphviz.WithWorkingTreeGraphVizLoader([bi], bi, False)
1880
211
        gv.load()
1881
212
        
1882
213
        state = loggraphviz.GraphVizFilterState(gv)
1883
214
        computed = gv.compute_viz(state)
1884
215
        
1885
216
        self.assertComputed(
1886
217
            [(u'current:%s' % tree.basedir, 0, True,                # ⊖  
1887
218
              [(0, 0, 0, True), (0, 1, 2, True)],                   # ├─╮ 
1888
219
              ['branch - Working Tree']),                           # │ │ 
1889
220
             ('rev-b', 1, None, [(0, 0, 0, True), (1, 0, 0, True)], # │ ○ 
1890
221
              ['branch - Pending Merge']),                          # ├─╯ 
1891
222
             ('rev-a', 0, None, [], ['branch'])],                   # ○ 
1892
223
            computed, branch_labels=True)
1893
224
    
1894
225
    def test_with_working_tree_provider_out_of_date_wt(self):
1895
226
        tree = self.make_tree_not_up_to_date('branch')
1896
227
        bi = loggraphviz.BranchInfo('branch', tree, tree.branch)
1897
228
        gv = loggraphviz.WithWorkingTreeGraphVizLoader([bi], bi, False)
1898
229
        gv.load()
1899
230
        
1900
231
        state = loggraphviz.GraphVizFilterState(gv)
1901
232
        computed = gv.compute_viz(state)
1902
233
        
1903
234
        self.assertComputed(
1904
235
            [(u'current:%s' % tree.basedir, 1, None, [(1, 1, 0, True)], #   ○ 
1905
236
              ['branch - Working Tree']),                               #   │ 
1906
237
             ('rev-b', 0, None, [(0, 0, 0, True), (1, 0, 0, True)],     # ○ │ 
1907
238
              ['branch']),                                              # ├─╯ 
1908
239
             ('rev-a', 0, None, [], []) ],                              # ○
1909
240
            computed, branch_labels=True)
1910
241
1911
242
    def test_with_working_tree_provider_filtered(self):
1912
243
        # This test makes sure that lable for a Working Tree shows for on it's
1913
244
        # nearest visble unique ansestor when the working tree node is
1914
245
        # filtered. 
1915
246
        builder = self.make_branch_builder('branch')
1916
247
        builder.start_series()
1917
248
        builder.build_snapshot('rev-a', None, [
1918
249
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
1919
250
        builder.build_snapshot('rev-b', ['rev-a'], [])
1920
251
        builder.build_snapshot('rev-c', ['rev-a'], [])
1921
252
        builder.finish_series()
1922
253
        
1923
254
        branch = builder.get_branch()
1924
255
        tree = branch.bzrdir.create_workingtree()
1925
256
        tree.update(revision='rev-b')
1926
257
        
1927
258
        bi = loggraphviz.BranchInfo('branch', tree, tree.branch)
1928
259
        gv = loggraphviz.WithWorkingTreeGraphVizLoader([bi], bi, False)
1929
260
        gv.load()
1930
261
        
1931
262
        state = loggraphviz.GraphVizFilterState(gv)
1932
263
        state.filters.append(BasicFilterer(set([
1933
264
            'current:%s' % tree.basedir.encode('unicode-escape')])))
1934
265
        computed = gv.compute_viz(state)
1935
266
        self.assertComputed(
1936
267
            [('rev-b', 1, None, [(1, 1, 0, True)], ['branch - Working Tree'])  , #   ○ 
1937
268
                                                                                 #   │ 
1938
269
             ('rev-c', 0, None, [(0, 0, 0, True), (1, 0, 0, True)], ['branch']), # ○ │ 
1939
270
                                                                                 # ├─╯ 
1940
271
             ('rev-a', 0, None, [], [])                                        ],# ○ 
1941
272
            computed, branch_labels=True)
1942
273
    
1943
274
    def test_pending_merges_provider(self):
1944
275
        tree = self.make_tree_with_pending_merge('branch')
1945
276
        
1946
277
        bi = loggraphviz.BranchInfo(None, tree, tree.branch)
1947
278
        gv = loggraphviz.PendingMergesGraphVizLoader([bi], bi, False)
1948
279
        gv.load()
1949
280
        
1950
281
        state = loggraphviz.GraphVizFilterState(gv)
1951
282
        computed = gv.compute_viz(state)
1952
283
        
1953
284
        self.assertComputed(
1954
285
            [('rev-b', 1, None, [(1, 0, 0, True)]), #   ○ 
1955
286
                                                    # ╭─╯ 
1956
287
             ('root:', 0, None, [])               ],# ○ 
1957
288
            computed)
1958
289
    
1959
290
    def test_with_ghost(self):
1960
291
        tree = self.make_branch_and_tree('tree')
1961
292
        tree.commit('a', rev_id='rev-a')
1962
293
        tree.add_parent_tree_id('rev-b')
1963
294
        tree.commit('c', rev_id='rev-c')
1964
295
        # rev-b is a ghost. We think he is there, but he dose not exist. Boo!
1965
296
        
1966
297
        bi = loggraphviz.BranchInfo(None, tree, tree.branch)
1967
298
        gv = loggraphviz.GraphVizLoader([bi], bi, False)
1968
299
        gv.load()
1969
300
        
1970
301
        state = loggraphviz.GraphVizFilterState(gv)
1971
302
        state.expand_all_branch_lines()
1972
303
        computed = gv.compute_viz(state)
1973
304
        
1974
305
        self.assertComputed(
1975
306
            [('rev-c', 0, True, [(0, 0, 0, True), (0, 1, 1, True)]), # ⊖   
1976
307
                                                                     # ├─╮ 
1977
308
             ('rev-b', 1, None, [(0, 0, 0, True)])                 , # │ ○ 
1978
309
                                                                     # │   
1979
310
             ('rev-a', 0, None, [])                                ],# ○ 
1980
311
            computed)
1981
312
1982
313
    def test_with_ghost_mainline(self):
1983
314
        tree = self.make_branch_and_tree('tree')
1984
315
        tree.add_parent_tree_id('rev-a', allow_leftmost_as_ghost=True)
1985
316
        tree.commit('b', rev_id='rev-b')
1986
317
        
1987
318
        bi = loggraphviz.BranchInfo(None, tree, tree.branch)
1988
319
        gv = loggraphviz.GraphVizLoader([bi], bi, False)
1989
320
        gv.load()
1990
321
        
1991
322
        state = loggraphviz.GraphVizFilterState(gv)
1992
323
        computed = gv.compute_viz(state)
1993
324
        
1994
325
        self.assertComputed(
1995
326
            [('rev-b', 0, None, [(0, 0, 0, True)]), # ○ 
1996
327
                                                    # │ 
1997
328
             ('rev-a', 0, None, [])               ],# ○
1998
329
            computed)
1999
330
2000
331
    def test_get_revid_branch_info(self):
2001
332
        builder = self.make_branch_builder('trunk')
2002
333
        builder.start_series()
2003
334
        builder.build_snapshot('rev-a', None, [
2004
335
            ('add', ('', 'TREE_ROOT', 'directory', '')),])
2005
336
        builder.build_snapshot('rev-branch', ['rev-a'], [])
2006
337
        builder.build_snapshot('rev-trunk', ['rev-a'], [])
2007
338
        builder.finish_series()
2008
339
        #   ○ branch
2009
340
        #   │ 
2010
341
        # ○ │ trunk
2011
342
        # ├─╯ 
2012
343
        # ○ rev-a
2013
344
        
2014
345
        trunk = builder.get_branch()
2015
346
        #trunk.set_last_revision('rev-trunk')
2016
347
        
2017
348
        branch = trunk.bzrdir.sprout('../branch',
2018
349
                                     revision_id='rev-branch').open_branch()
2019
350
        
2020
351
        trunk_bi = loggraphviz.BranchInfo('trunk', None, trunk)
2021
352
        branch_bi = loggraphviz.BranchInfo('branch', None, branch)
2022
353
        gv = loggraphviz.GraphVizLoader(
2023
354
            [trunk_bi, branch_bi],
2024
355
            trunk_bi, False)
2025
356
        gv.load()
2026
357
        
2027
358
        self.assertEqual(trunk_bi, gv.get_revid_branch_info('rev-trunk'))
2028
359
        self.assertEqual(branch_bi, gv.get_revid_branch_info('rev-branch'))
2029
360
        
2030
361
        # may return either 
2031
362
        self.assertIn(gv.get_revid_branch_info('rev-a'),
2032
363
                      (branch_bi, trunk_bi))
2033
364
2034
365
    def test_get_revid_branch_info_with_ghost(self):
2035
366
        tree = self.make_branch_and_tree('tree')
2036
367
        tree.commit('a', rev_id='rev-a')
2037
368
        tree.add_parent_tree_id('rev-b')
2038
369
        tree.commit('c', rev_id='rev-c')
2039
370
        # rev-b is a ghost. We think he is there, but he dose not exist. Boo!
2040
371
        # c 
2041
372
        # ├─╮
2042
373
        # │ b
2043
374
        # │ 
2044
375
        # a 
2045
376
2046
377
        bi = loggraphviz.BranchInfo(None, tree, tree.branch)
2047
378
        gv = loggraphviz.GraphVizLoader([bi], bi, False)
2048
379
        gv.load()
2049
380
        
2050
381
        self.assertRaises(loggraphviz.GhostRevisionError,
2051
382
                          gv.get_revid_branch_info, 'rev-b')
2052
383
2053
384
class TestLogGraphVizLayouts(TestCase, TestLogGraphVizMixin):
2054
385
    
2055
386
    def test_basic_branch_line(self):
2056
387
        gv = BasicGraphVizLoader(('rev-d',), {
2057
388
         'rev-a': (NULL_REVISION, ), 
2058
389
         'rev-b': ('rev-a', ),
2059
390
         'rev-c': ('rev-a', ),
2060
391
         'rev-d': ('rev-b', 'rev-c'),
2061
392
        })
2062
393
        gv.load()
2063
394
        
2064
395
        state = loggraphviz.GraphVizFilterState(gv)
2065
396
        computed = gv.compute_viz(state)
2066
397
        
2067
398
        # only mainline.
2068
399
        self.assertComputed(
2069
400
            [('rev-d', 0, False, [(0, 0, 0, True)]), # ⊕ 
2070
401
                                                     # │ 
2071
402
             ('rev-b', 0, None, [(0, 0, 0, True)]) , # ○ 
2072
403
                                                     # │ 
2073
404
             ('rev-a', 0, None, [])                ],# ○ 
2074
405
             computed)
2075
406
      
2076
407
        state.collapse_expand_rev(computed.filtered_revs[0])
2077
408
        computed = gv.compute_viz(state)
2078
409
        
2079
410
        # expanded branch line.
2080
411
        self.assertComputed(
2081
412
            [('rev-d', 0, True, [(0, 0, 0, True), (0, 1, 2, True)]), # ⊖   
2082
413
                                                                     # ├─╮ 
2083
414
             ('rev-c', 1, None, [(0, 0, 0, True), (1, 1, 0, True)]), # │ ○ 
2084
415
                                                                     # │ │ 
2085
416
             ('rev-b', 0, None, [(0, 0, 0, True), (1, 0, 0, True)]), # ○ │ 
2086
417
                                                                     # ├─╯ 
2087
418
             ('rev-a', 0, None, [])                                ],# ○ 
2088
419
            computed)
2089
420
    
2090
421
    def test_branch_line_order(self):
2091
422
        gv = BasicGraphVizLoader(('rev-f',), {
2092
423
         'rev-a': (NULL_REVISION, ), 
2093
424
         'rev-b': ('rev-a', ),
2094
425
         'rev-c': ('rev-b', ),
2095
426
         'rev-d': ('rev-a', 'rev-c'),
2096
427
         'rev-e': ('rev-b', ),
2097
428
         'rev-f': ('rev-d', 'rev-e' ),
2098
429
        })
2099
430
        gv.load()
2100
431
        
2101
432
        state = loggraphviz.GraphVizFilterState(gv)
2102
433
        state.expand_all_branch_lines()
2103
434
        computed = gv.compute_viz(state)
2104
435
        
2105
436
        # branch lines should not cross over
2106
437
        self.assertComputed(
2107
438
            [('rev-f', 0, True, [(0, 0, 0, True), (0, 2, 3, True)])                 , # ⊖     
2108
439
                                                                                      # ├───╮ 
2109
440
             ('rev-e', 2, True, [(0, 0, 0, True), (2, 2, 2, True)])                 , # │   ⊖ 
2110
441
                                                                                      # │   │ 
2111
442
             ('rev-d', 0, True, [(0, 0, 0, True), (0, 1, 2, True), (2, 2, 2, True)]), # ⊖   │ 
2112
443
                                                                                      # ├─╮ │ 
2113
444
             ('rev-c', 1, None, [(0, 0, 0, True), (1, 1, 2, True), (2, 1, 2, True)]), # │ ○ │ 
2114
445
                                                                                      # │ ├─╯ 
2115
446
             ('rev-b', 1, None, [(0, 0, 0, True), (1, 0, 0, True)])                 , # │ ○ 
2116
447
                                                                                      # ├─╯ 
2117
448
             ('rev-a', 0, None, [])                                                 ],# ○ 
2118
449
             computed)
2119
450
2120
451
    def test_branch_line_order2(self):
2121
452
        gv = BasicGraphVizLoader(('rev-h',), {
2122
453
         'rev-a': (NULL_REVISION, ), 
2123
454
         'rev-b': ('rev-a', ),
2124
455
         'rev-c': ('rev-b', ),
2125
456
         'rev-d': ('rev-a', ),
2126
457
         'rev-e': ('rev-d', 'rev-b' ),
2127
458
         'rev-f': ('rev-e', ),
2128
459
         'rev-g': ('rev-e', 'rev-f' ),
2129
460
         'rev-h': ('rev-c', 'rev-g' ),
2130
461
        })
2131
462
        gv.load()
2132
463
        
2133
464
        state = loggraphviz.GraphVizFilterState(gv)
2134
465
        state.expand_all_branch_lines()
2135
466
        computed = gv.compute_viz(state)
2136
467
2137
468
        # branch lines should not cross over
2138
469
        self.assertComputed(
2139
470
            [('rev-h', 0, True, [(0, 0, 0, True), (0, 2, 2, True)])                 , # ⊖     
2140
471
                                                                                      # ├───╮ 
2141
472
             ('rev-g', 2, True, [(0, 0, 0, True), (2, 2, 2, True), (2, 3, 3, True)]), # │   ⊖   
2142
473
                                                                                      # │   ├─╮ 
2143
474
             ('rev-f', 3, None, [(0, 0, 0, True), (2, 2, 2, True), (3, 2, 2, True)]), # │   │ ○ 
2144
475
                                                                                      # │   ├─╯ 
2145
476
             ('rev-e', 2, None, [(0, 0, 0, True), (2, 1, 0, True), (2, 2, 2, True)]), # │   ○ 
2146
477
                                                                                      # │ ╭─┤ 
2147
478
             ('rev-d', 2, None, [(0, 0, 0, True), (1, 1, 0, True), (2, 2, 0, True)]), # │ │ ○ 
2148
479
                                                                                      # │ │ │ 
2149
480
             ('rev-c', 0, None, [(0, 0, 0, True), (1, 0, 0, True), (2, 2, 0, True)]), # ○ │ │ 
2150
481
                                                                                      # ├─╯ │ 
2151
482
             ('rev-b', 0, None, [(0, 0, 0, True), (2, 0, 0, True)])                 , # ○   │ 
2152
483
                                                                                      # ├───╯ 
2153
484
             ('rev-a', 0, None, [])                                                 ],# ○ 
2154
485
             computed)
2155
486
2156
487
    def test_octopus_merge(self):
2157
488
        gv = BasicGraphVizLoader(('rev-e',), {
2158
489
         'rev-a': (NULL_REVISION, ), 
2159
490
         'rev-b': ('rev-a', ),
2160
491
         'rev-c': ('rev-a', ),
2161
492
         'rev-d': ('rev-a', ),
2162
493
         'rev-e': ('rev-a', 'rev-b', 'rev-c', 'rev-d'),
2163
494
        })
2164
495
        gv.load()
2165
496
        
2166
497
        state = loggraphviz.GraphVizFilterState(gv)
2167
498
        state.expand_all_branch_lines()
2168
499
        computed = gv.compute_viz(state)
2169
500
        
2170
501
        self.assertComputed(
2171
502
            [('rev-e', 0, True, [(0, 0, 0, True), (0, 1, 2, True), (0, 2, 3, True), (0, 3, 4, True)]), # ⊖       
2172
503
                                                                                                       # ├─╮─╮─╮ 
2173
504
             ('rev-b', 3, None, [(0, 0, 0, True), (1, 1, 2, True), (2, 2, 3, True), (3, 3, 0, True)]), # │ │ │ ○ 
2174
505
                                                                                                       # │ │ │ │ 
2175
506
             ('rev-c', 2, None, [(0, 0, 0, True), (1, 1, 2, True), (2, 2, 0, True), (3, 3, 0, True)]), # │ │ ○ │ 
2176
507
                                                                                                       # │ │ │ │ 
2177
508
             ('rev-d', 1, None, [(0, 0, 0, True), (1, 0, 0, True), (2, 0, 0, True), (3, 0, 0, True)]), # │ ○ │ │ 
2178
509
                                                                                                       # ├─╯─╯─╯ 
2179
510
             ('rev-a', 0, None, [])                                                                  ],# ○
2180
511
            computed)
2181
512
2182
513
    def test_lots_of_merges_between_branch_lines(self):
2183
514
        gv = BasicGraphVizLoader(('rev-g',), {
2184
515
         'rev-a': (NULL_REVISION, ), 
2185
516
         'rev-b': ('rev-a', ),
2186
517
         'rev-c': ('rev-b', ),
2187
518
         'rev-d': ('rev-a', ),
2188
519
         'rev-e': ('rev-d', 'rev-b',),
2189
520
         'rev-f': ('rev-e', 'rev-c',),
2190
521
         'rev-g': ('rev-c', 'rev-f',),
2191
522
        })
2192
523
        gv.load()
2193
524
        
2194
525
        state = loggraphviz.GraphVizFilterState(gv)
2195
526
        state.expand_all_branch_lines()
2196
527
        computed = gv.compute_viz(state)
2197
528
2198
529
        self.assertComputed(
2199
530
            [('rev-g', 0, True, [(0, 0, 0, True), (0, 2, 2, True)])                                           , # ⊖     
2200
531
                                                                                                                # ├───╮ 
2201
532
             ('rev-f', 2, None, [(0, 0, 0, True), (2, 0.75, 0, True), (2, 2, 2, True)])                       , # │   ○ 
2202
533
                                                                                                                # │ ╭─┤ 
2203
534
             ('rev-e', 2, None, [(0, 0, 0, True), (0.75, 0.75, 0, True), (2, 1.25, 0, True), (2, 2, 2, True)]), # │ │ ○ 
2204
535
                                                                                                                # │ ├─┤ 
2205
536
             ('rev-d', 2, None, [(0, 0, 0, True), (0.75, 0, 0, True), (1.25, 1.25, 0, True), (2, 2, 0, True)]), # │ │ ○ 
2206
537
                                                                                                                # ├─┤ │ 
2207
538
             ('rev-c', 0, None, [(0, 0, 0, True), (1.25, 0, 0, True), (2, 2, 0, True)])                       , # ○ │ │ 
2208
539
                                                                                                                # ├─╯ │ 
2209
540
             ('rev-b', 0, None, [(0, 0, 0, True), (2, 0, 0, True)])                                           , # ○   │ 
2210
541
                                                                                                                # ├───╯ 
2211
542
             ('rev-a', 0, None, [])                                                                           ],# ○ 
2212
543
            computed)
2213
544
    
2214
545
    def test_hidden_branch_line_hides_child_line(self):
2215
546
        gv = BasicGraphVizLoader(('rev-g',), {
2216
547
         'rev-a': (NULL_REVISION, ), 
2217
548
         'rev-b': ('rev-a', ),
2218
549
         'rev-c': ('rev-a', ),
2219
550
         'rev-d': ('rev-b', 'rev-c', ),
2220
551
         'rev-e': ('rev-b', 'rev-d', ),
2221
552
         'rev-f': ('rev-c', ),
2222
553
         'rev-g': ('rev-e', 'rev-f', ),
2223
554
        })
2224
555
        gv.load()
2225
556
        
2226
557
        state = loggraphviz.GraphVizFilterState(gv)
2227
558
        state.branch_line_state[(2, 1)] = None
2228
559
        computed = gv.compute_viz(state)
2229
560
        
2230
561
        self.assertComputed(
2231
562
            [('rev-g', 0, False, [(0, 0, 0, True)])                 , # ⊕ 
2232
563
                                                                      # │ 
2233
564
             ('rev-e', 0, True, [(0, 0, 0, True), (0, 1, 3, True)]) , # ⊖   
2234
565
                                                                      # ├─╮ 
2235
566
             ('rev-d', 1, False, [(0, 0, 0, True), (1, 0, 0, True)]), # │ ⊕ 
2236
567
                                                                      # ├─╯ 
2237
568
             ('rev-b', 0, None, [(0, 0, 0, True)])                  , # ○ 
2238
569
                                                                      # │ 
2239
570
             ('rev-a', 0, None, [])                                 ],# ○ 
2240
571
             computed)
2241
572
    
2242
573
    def test_merge_line_hidden(self):
2243
574
        gv = BasicGraphVizLoader(('rev-d',), {
2244
575
         'rev-a': (NULL_REVISION, ), 
2245
576
         'rev-b': ('rev-a', ),
2246
577
         'rev-c': ('rev-a', 'rev-b'),
2247
578
         'rev-d': ('rev-a', 'rev-c'),
2248
579
        })
2249
580
        # d 
2250
581
        # ├─╮ 
2251
582
        # │ c 
2252
583
        # │ ├─╮ 
2253
584
        # │ │ b
2254
585
        # ├─╯─╯ 
2255
586
        # a
2256
587
        gv.load()
2257
588
        
2258
589
        state = loggraphviz.GraphVizFilterState(gv)
2259
590
        state.branch_line_state[(1, 1)] = None
2260
591
        
2261
592
        computed = gv.compute_viz(state)
2262
593
        # when the merge by branch line, we should show a non direct line
2263
594
        self.assertComputed(
2264
595
            [('rev-d', 0, False, [(0, 0, 0, True), (0, 1, 2, False)]), # ⊕   
2265
596
                                                                       # ├┄╮ 
2266
597
             ('rev-b', 1, None, [(0, 0, 0, True), (1, 0, 0, True)])  , # │ ○ 
2267
598
                                                                       # ├─╯ 
2268
599
             ('rev-a', 0, None, [])                                  ],# ○ 
2269
600
            computed)
2270
601
2271
602
    def test_merge_line_hidden2(self):
2272
603
        gv = BasicGraphVizLoader(('rev-e',), {
2273
604
         'rev-a': (NULL_REVISION, ), 
2274
605
         'rev-z': ('rev-a', ),
2275
606
         'rev-y': ('rev-a', 'rev-z', ),
2276
607
         'rev-b': ('rev-a', ),
2277
608
         'rev-c': ('rev-a', ),
2278
609
         'rev-d': ('rev-a', 'rev-c'),
2279
610
         'rev-e': ('rev-y', 'rev-b', 'rev-d'),
2280
611
        })
2281
612
        # f     
2282
613
        # ├─╮─╮ 
2283
614
        # │ b │ 
2284
615
        # │ │ │ 
2285
616
        # │ │ e   
2286
617
        # │ │ ├─╮ 
2287
618
        # │ │ │ d
2288
619
        # ├─╯─╯─╯ 
2289
620
        # a
2290
621
        gv.load()
2291
622
        
2292
623
        state = loggraphviz.GraphVizFilterState(gv)
2293
624
        #state.expand_all_branch_lines()
2294
625
        state.branch_line_state[(1, 1)] = None
2295
626
        state.branch_line_state[(1, 2)] = None
2296
627
        #state.branch_line_state[(1, 3)] = None
2297
628
        state.branch_line_state[(1, 4)] = None
2298
629
        
2299
630
        computed = gv.compute_viz(state)
2300
631
        # when the merge by branch line, we should show a non direct line
2301
632
        # this could layout better, but that's another story...
2302
633
        self.assertComputed(
2303
634
            [('rev-e', 0, False, [(0, 0, 0, True), (0, 1, 3, False), (0, 2, 5, True)])               , # ⊕     
2304
635
                                                                                                       # ├┄╮─╮ 
2305
636
             ('rev-b', 2, None, [(0, 0, 0, True), (1, 3, 3, False), (2, 2, 0, True)])                , # │ ┆ ○   
2306
637
                                                                                                       # │ ╰┄┼┄╮ 
2307
638
             ('rev-c', 3, None, [(0, 0, 0, True), (2, 2, 0, True), (3, 3, 0, True)])                 , # │   │ ○ 
2308
639
                                                                                                       # │   │ │ 
2309
640
             ('rev-y', 0, True, [(0, 0, 0, True), (0, 1, 2, True), (2, 2, 0, True), (3, 3, 0, True)]), # ⊖   │ │ 
2310
641
                                                                                                       # ├─╮ │ │ 
2311
642
             ('rev-z', 1, None, [(0, 0, 0, True), (1, 0, 0, True), (2, 0, 0, True), (3, 0, 0, True)]), # │ ○ │ │ 
2312
643
                                                                                                       # ├─╯─╯─╯ 
2313
644
             ('rev-a', 0, None, [])                                                                  ],# ○ 
2314
645
            computed)
2315
646
    
2316
647
    def test_merge_line_hidden_merge_rev_filtered(self):
2317
648
        gv = BasicGraphVizLoader(('rev-e',), {
2318
649
         'rev-a': (NULL_REVISION, ), 
2319
650
         'rev-b': ('rev-a', ),
2320
651
         'rev-c': ('rev-b', ),
2321
652
         'rev-d': ('rev-a', 'rev-c'),
2322
653
         'rev-e': ('rev-a', 'rev-d'),
2323
654
        })
2324
655
        gv.load()
2325
656
        
2326
657
        state = loggraphviz.GraphVizFilterState(gv)
2327
658
        state.filters.append(BasicFilterer(set(['rev-c'])))
2328
659
        state.branch_line_state[(1, 1)] = None
2329
660
        
2330
661
        computed = gv.compute_viz(state)
2331
662
        
2332
663
        # when the merge by branch line, we should show a non direct line
2333
664
        self.assertComputed(
2334
665
            [('rev-e', 0, False, [(0, 0, 0, True), (0, 1, 2, False)]), # ⊕   
2335
666
                                                                       # ├┄╮ 
2336
667
             ('rev-b', 1, None, [(0, 0, 0, True), (1, 0, 0, True)])  , # │ ○ 
2337
668
                                                                       # ├─╯ 
2338
669
             ('rev-a', 0, None, [])                                  ],# ○ 
2339
670
            computed)    
2340
671
2341
672
    def test_non_direct_hidden_branch(self):
2342
673
        gv = BasicGraphVizLoader(('rev-f',), {
2343
674
         'rev-a': (NULL_REVISION, ), 
2344
675
         'rev-b': ('rev-a', ),
2345
676
         'rev-c': ('rev-b', ),
2346
677
         'rev-d': ('rev-a', 'rev-c', ),
2347
678
         'rev-e': ('rev-b', ),
2348
679
         'rev-f': ('rev-d', 'rev-e', ),
2349
680
        })
2350
681
        gv.load()
2351
682
        
2352
683
        state = loggraphviz.GraphVizFilterState(gv)
2353
684
        state.branch_line_state[(1, 2)] = None
2354
685
        
2355
686
        computed = gv.compute_viz(state)
2356
687
        
2357
688
        self.assertComputed(
2358
689
            [('rev-f', 0, True, [(0, 0, 0, True), (0, 1, 3, True)])  , # ⊖   
2359
690
                                                                       # ├─╮ 
2360
691
             ('rev-e', 1, False, [(0, 0, 0, True), (1, 1, 0, False)]), # │ ⊕ 
2361
692
                                                                       # │ ┆ 
2362
693
             ('rev-d', 0, False, [(0, 0, 0, True), (1, 0, 0, False)]), # ⊕ ┆ 
2363
694
                                                                       # ├┄╯ 
2364
695
             ('rev-a', 0, None, [])                                  ],# ○
2365
696
            computed)
2366
697
2367
698
    def test_non_direct_hidden_parent(self):
2368
699
        gv = BasicGraphVizLoader(('rev-e',), {
2369
700
         'rev-a': (NULL_REVISION, ), 
2370
701
         'rev-b': ('rev-a', ),
2371
702
         'rev-c': ('rev-b', ),
2372
703
         'rev-d': ('rev-a', 'rev-c'),
2373
704
         'rev-e': ('rev-a', 'rev-d'),
2374
705
        })
2375
706
        gv.load()
2376
707
        
2377
708
        state = loggraphviz.GraphVizFilterState(gv)
2378
709
        state.filters.append(BasicFilterer(set(['rev-c'])))
2379
710
        state.expand_all_branch_lines()
2380
711
        
2381
712
        computed = gv.compute_viz(state)
2382
713
        
2383
714
        self.assertComputed(
2384
715
            [('rev-e', 0, True, [(0, 0, 0, True), (0, 1, 3, True)])                  , # ⊖   
2385
716
                                                                                       # ├─╮ 
2386
717
             ('rev-d', 1, True, [(0, 0, 0, True), (1, 1, 0, True), (1, 2, 2, False)]), # │ ⊖   
2387
718
                                                                                       # │ ├┄╮ 
2388
719
             ('rev-b', 2, None, [(0, 0, 0, True), (1, 0, 0, True), (2, 0, 0, True)]) , # │ │ ○ 
2389
720
                                                                                       # ├─╯─╯ 
2390
721
             ('rev-a', 0, None, [])                                                  ],# ○
2391
722
            computed)
2392
723
2393
724
    def test_no_graph(self):
2394
725
        gv = BasicGraphVizLoader(('rev-d',), {
2395
726
         'rev-a': (NULL_REVISION, ), 
2396
727
         'rev-b': ('rev-a', ),
2397
728
         'rev-c': ('rev-a', ),
2398
729
         'rev-d': ('rev-b', 'rev-c'),
2399
730
        }, no_graph=True)
2400
731
        gv.load()
2401
732
        
2402
733
        state = loggraphviz.GraphVizFilterState(gv)
2403
734
        computed = gv.compute_viz(state)
2404
735
        self.assertComputed(
2405
736
            [('rev-d', 0.0, None, []), # ○ 
2406
737
                                       #   
2407
738
             ('rev-c', 0.5, None, []), #  ○ 
2408
739
                                       #    
2409
740
             ('rev-b', 0.0, None, []), # ○ 
2410
741
                                       #   
2411
742
             ('rev-a', 0.0, None, [])],# ○ 
2412
743
            computed)
2413
744
    
2414
745
    def test_no_graph_filtered(self):
2415
746
        gv = BasicGraphVizLoader(('rev-d',), {
2416
747
         'rev-a': (NULL_REVISION, ), 
2417
748
         'rev-b': ('rev-a', ),
2418
749
         'rev-c': ('rev-a', ),
2419
750
         'rev-d': ('rev-b', 'rev-c'),
2420
751
        }, no_graph=True)
2421
752
        gv.load()
2422
753
        
2423
754
        state = loggraphviz.GraphVizFilterState(gv)
2424
755
        state.filters.append(BasicFilterer(set(['rev-b'])))
2425
756
        computed = gv.compute_viz(state)
2426
757
        self.assertComputed(
2427
758
            [('rev-d', 0.0, None, []), # ○ 
2428
759
                                       #   
2429
760
             ('rev-c', 0.5, None, []), #  ○ 
2430
761
                                       # 
2431
762
             ('rev-a', 0.0, None, [])],# ○ 
2432
763
            computed)
2433
764
2434
765
class TestLogGraphProviderState(TestCase):
2435
766
2436
767
    def assertFilteredRevisions(self, expected_revids, state):
2437
768
        revids = [rev.revid for rev in state.get_filtered_revisions()]
2438
769
        self.assertEqual(list(expected_revids), revids)
2439
770
    
2440
771
    def test_collapse_expand_rev_basic(self):
2441
772
        gv = BasicGraphVizLoader(('c',), {
2442
773
         'a': (NULL_REVISION, ), 
2443
774
         'b': ('a', ),
2444
775
         'c': ('a', 'b'),
2445
776
        })
2446
777
        gv.load()
2447
778
        # c  
2448
779
        # ├─╮ 
2449
780
        # │ b
2450
781
        # ├─╯ 
2451
782
        # a
2452
783
        
2453
784
        state = loggraphviz.GraphVizFilterState(gv)
2454
785
        
2455
786
        # just mainline showing
2456
787
        self.assertFilteredRevisions('ca', state)
2457
788
        
2458
789
        # bla - we need a computed to call collapse_expand_rev
2459
790
        # expand 'c'
2460
791
        state.collapse_expand_rev(gv.compute_viz(state).filtered_revs[0])
2461
792
        
2462
793
        # all should be showing
2463
794
        self.assertFilteredRevisions('cba', state)
2464
795
        
2465
796
        # colapse 'c'
2466
797
        state.collapse_expand_rev(gv.compute_viz(state).filtered_revs[0])
2467
798
        
2468
799
        # just mainline showing
2469
800
        self.assertFilteredRevisions('ca', state)
2470
801
2471
802
    def get_expanded_by_graph_provider(self):
2472
803
        gv = BasicGraphVizLoader(('f',), {
2473
804
         'a': (NULL_REVISION, ), 
2474
805
         'b': ('a', ),
2475
806
         'c': ('a', 'b'),
2476
807
         'd': ('a', 'c', ),
2477
808
         'e': ('b', ),
2478
809
         'f': ('d', 'e')
2479
810
        })
2480
811
        gv.load()
2481
812
        # f     
2482
813
        # ├───╮ 
2483
814
        # │   e
2484
815
        # │   │ 
2485
816
        # d   │ 
2486
817
        # ├─╮ │ 
2487
818
        # │ c │ 
2488
819
        # │ │\│ 
2489
820
        # │ │ b
2490
821
        # ├─╯─╯ 
2491
822
        # a 
2492
823
        return gv
2493
824
    
2494
825
    def test_collapse_colapses_sub_expand(self):
2495
826
        gv = self.get_expanded_by_graph_provider()
2496
827
        
2497
828
        state = loggraphviz.GraphVizFilterState(gv)
2498
829
        # just mainline showing
2499
830
        self.assertFilteredRevisions('fda', state)
2500
831
        
2501
832
        # expand 'd'
2502
833
        state.collapse_expand_rev(gv.compute_viz(state).revisions[2])
2503
834
        # branchline c now showing
2504
835
        self.assertFilteredRevisions('fdca', state)
2505
836
        
2506
837
        # expand 'c'
2507
838
        state.collapse_expand_rev(gv.compute_viz(state).revisions[3])
2508
839
        # all showing
2509
840
        self.assertFilteredRevisions('fedcba', state)
2510
841
        
2511
842
        # colapse 'd'
2512
843
        state.collapse_expand_rev(gv.compute_viz(state).filtered_revs[2])
2513
844
        # cause c expanded branchline eb, and d expanded c, d colapses 
2514
845
        # just mainline showing
2515
846
        self.assertFilteredRevisions('fda', state)
2516
847
2517
848
    def test_collapse_dosent_colapses_prev_expand(self):
2518
849
        gv = self.get_expanded_by_graph_provider()
2519
850
        
2520
851
        state = loggraphviz.GraphVizFilterState(gv)
2521
852
        # just mainline showing
2522
853
        self.assertFilteredRevisions('fda', state)
2523
854
        
2524
855
        # expand 'f'
2525
856
        state.collapse_expand_rev(gv.compute_viz(state).revisions[0])
2526
857
        # branchline eb now showing
2527
858
        self.assertFilteredRevisions('fedba', state)
2528
859
        
2529
860
        # expand 'd'
2530
861
        state.collapse_expand_rev(gv.compute_viz(state).revisions[2])
2531
862
        # all showing
2532
863
        self.assertFilteredRevisions('fedcba', state)
2533
864
        
2534
865
        # colapse 'd'
2535
866
        state.collapse_expand_rev(gv.compute_viz(state).filtered_revs[2])
2536
867
        # cause branchline eb was expanded by f, and not d, collapsing d dose
2537
868
        # not collapse branchline eb, even though it expanded it
2538
869
        # branchline eb and mainline left showing
2539
870
        self.assertFilteredRevisions('fedba', state)
2540
871
2541
872
    def test_collapse_deep_expanded_by(self):
2542
873
        # This use to error at one point
2543
874
        gv = BasicGraphVizLoader(('g',), {
2544
875
         'a': (NULL_REVISION, ), 
2545
876
         'b': ('a', ),
2546
877
         'c': ('a', 'b'),
2547
878
         'd': ('a', 'c', ),
2548
879
         'e': ('b', ),
2549
880
         'f': ('d', 'e'),
2550
881
         'g': ('a', 'f'),
2551
882
        })
2552
883
        # g v-----1.3 
2553
884
        # ├─╮ 
2554
885
        # │ f   v-1.1
2555
886
        # │ ├───╮ 
2556
887
        # │ │   e
2557
888
        # │ │   │ 
2558
889
        # │ d v-│-1.2
2559
890
        # │ ├─╮ │ 
2560
891
        # │ │ c │ 
2561
892
        # │ │ │\│ 
2562
893
        # │ │ │ b
2563
894
        # ├─╯─╯─╯ 
2564
895
        # a 
2565
896
        
2566
897
        gv.load()
2567
898
        
2568
899
        state = loggraphviz.GraphVizFilterState(gv)
2569
900
        # just mainline showing
2570
901
        self.assertFilteredRevisions('ga', state)
2571
902
        
2572
903
        # expand 'g'
2573
904
        state.collapse_expand_rev(gv.compute_viz(state).revisions[0])
2574
905
        # branchline fd now showing
2575
906
        self.assertFilteredRevisions('gfda', state)
2576
907
        
2577
908
        # expand 'f'
2578
909
        state.collapse_expand_rev(gv.compute_viz(state).revisions[1])
2579
910
        # branchline eb now showing
2580
911
        self.assertFilteredRevisions('gfedba', state)
2581
912
        
2582
913
        # expand 'd'
2583
914
        state.collapse_expand_rev(gv.compute_viz(state).revisions[3])
2584
915
        # branchline c now showing (all showing)
2585
916
        self.assertFilteredRevisions('gfedcba', state)
2586
917
2587
918
        # colapse 'g'
2588
919
        state.collapse_expand_rev(gv.compute_viz(state).filtered_revs[0])
2589
920
        # back to just mainline showing
2590
921
        self.assertFilteredRevisions('ga', state)
2591
922
    
2592
923
    def test_filter(self):
2593
924
        gv = BasicGraphVizLoader(('e',), {
2594
925
         'a': (NULL_REVISION, ), 
2595
926
         'b': ('a', ),
2596
927
         'c': ('a', 'b'),
2597
928
         'd': ('c', ),
2598
929
         'e': ('d', ),
2599
930
        })
2600
931
        gv.load()
2601
932
        # e
2602
933
        # │
2603
934
        # d
2604
935
        # │
2605
936
        # c  
2606
937
        # ├─╮ 
2607
938
        # │ b
2608
939
        # ├─╯ 
2609
940
        # a
2610
941
        
2611
942
        state = loggraphviz.GraphVizFilterState(gv)
2612
943
        
2613
944
        # expand 'c'
2614
945
        state.collapse_expand_rev(gv.compute_viz(state).filtered_revs[2])
2615
946
        
2616
947
        # all should be showing
2617
948
        self.assertFilteredRevisions('edcba', state)
2618
949
        
2619
950
        state.filters.append(BasicFilterer(('d', 'c', 'a')))
2620
951
        state.filter_changed()
2621
952
        # d and a not showing bucause of filter
2622
953
        # c shows even though it is filtered, because it merges a revision
2623
954
        # that is not filtered.
2624
955
        self.assertFilteredRevisions('ecb', state)
2625
956
2626
957
2627
958
    
2628
959
class BasicGraphVizLoader(loggraphviz.GraphVizLoader):
2629
960
    
2630
961
    def __init__(self, heads, graph_dict, no_graph=False):
2631
962
        self.heads = heads
2632
963
        self.graph_dict = graph_dict
2633
964
        bi = loggraphviz.BranchInfo(None, None, None)
2634
965
        loggraphviz.GraphVizLoader.__init__(self, [bi], bi, no_graph)
2635
966
    
2636
967
    def load(self):
2637
968
        for head in self.heads:
2638
969
            self.append_head_info(head, self.branches[0], head)
2639
970
        
2640
971
        self.process_graph_parents(self.heads, self.graph_dict.items())
2641
972
        
2642
973
        self.compute_head_info()
2643
974
        
2644
975
        if not self.no_graph:
2645
976
            self.compute_branch_lines()
2646
977
            self.compute_merge_info()
2647
978
2648
979
2649
980
class BasicFilterer(object):
2650
981
    def __init__(self, filtered_revids):
2651
982
        self.filtered_revids = filtered_revids
2652
983
    
2653
984
    def get_revision_visible(self, rev):
2654
985
        return rev.revid not in self.filtered_revids
2655
986
2656
987
def print_computed(computed):
2657
988
    print_lines([(c_rev.rev.revid,
2658
989
                 c_rev.col_index,
2659
990
                 c_rev.twisty_state,
2660
991
                 c_rev.lines,)
2661
992
                for c_rev in computed.filtered_revs])
2662
993
2663
994
def print_lines(list):
2664
995
    print ''
2665
996
    print format_graph_lines(list)
2666
997
2667
998
def format_graph_lines(list, use_unicode=True):
2668
999
    if not list:
2669
1000
        return list.__repr__() + '\n'
2670
1001
    s = StringIO()
2671
1002
    item_repr = [item.__repr__() for item in list]
2672
1003
    repr_width = max([len(repr) for repr in item_repr])
2673
1004
    if use_unicode:
2674
1005
        twisty_char = {None: u'○',
2675
1006
                      True: u'⊖',
2676
1007
                      False: u'⊕'}
2677
1008
        ver_char = {True: u'│',
2678
1009
                    False: u'┆'}
2679
1010
        
2680
1011
        hor_char = {True: {u' ': u'─',
2681
1012
                           u'│': u'┼',
2682
1013
                           u'┆': u'┼'},
2683
1014
                    False: {u' ': u'┄',
2684
1015
                           u'│': u'┼',
2685
1016
                           u'┆': u'┼'}}
2686
1017
        
2687
1018
        tl_char = {u' ': u'╭',
2688
1019
                   u'│': u'├',
2689
1020
                   u'┆': u'├',
2690
1021
                   u'─': u'┬',
2691
1022
                   u'┄': u'┬',
2692
1023
                   u'┴': u'┼',
2693
1024
                   u'┤': u'┼',}
2694
1025
    
2695
1026
        tr_char = {u' ': u'╮',
2696
1027
                   u'│': u'┤',
2697
1028
                   u'┆': u'┤',
2698
1029
                   u'─': u'┬',
2699
1030
                   u'┄': u'┬',
2700
1031
                   u'┴': u'┼',
2701
1032
                   u'├': u'┼',}
2702
1033
    
2703
1034
        bl_char = {u' ': u'╰',
2704
1035
                   u'│': u'├',
2705
1036
                   u'┆': u'├',
2706
1037
                   u'─': u'┴',
2707
1038
                   u'┄': u'┴',
2708
1039
                   u'┬': u'┼',
2709
1040
                   u'┤': u'┼',}
2710
1041
        
2711
1042
        br_char = {u' ': u'╯',
2712
1043
                   u'│': u'┤',
2713
1044
                   u'┆': u'┤',
2714
1045
                   u'─': u'┴',
2715
1046
                   u'┄': u'┴',
2716
1047
                   u'┬': u'┼',
2717
1048
                   u'├': u'┼',}
2718
1049
    else:
2719
1050
        twisty_char = {None: '*',
2720
1051
                      True: '~',
2721
1052
                      False: '+'}
2722
1053
        ver_char = {True: '|',
2723
1054
                    False: ':'}
2724
1055
        
2725
1056
        hor_char = {True: {' ': '-',},
2726
1057
                    False: {' ': '-'}}
2727
1058
        
2728
1059
        tl_char = {}
2729
1060
    
2730
1061
        tr_char = {}
2731
1062
    
2732
1063
        bl_char = {}
2733
1064
        
2734
1065
        br_char = {}
2735
1066
    
2736
1067
    for row, (item, repr) in enumerate(zip(list, item_repr)):
2737
1068
        if row == 0:
2738
1069
            s.write('[')
2739
1070
        else:
2740
1071
            s.write(' ')
2741
1072
        s.write(repr.ljust(repr_width))
2742
1073
        if row == len(list)-1:
2743
1074
            s.write('] # ')
2744
1075
        else:
2745
1076
            s.write(', # ')
2746
1077
        
2747
1078
        if len(item) == 4:
2748
1079
            revid, col_index, twisty_state, lines = item
2749
1080
        if len(item) == 5:
2750
1081
            revid, col_index, twisty_state, lines, labels = item
2751
1082
        
2752
1083
        all_cols = [col_index]
2753
1084
        all_cols += [start for start, end, color, direct in lines]
2754
1085
        all_cols += [end for start, end, color, direct in lines]
2755
1086
        num_cols = (max(all_cols) + 1) * 2
2756
1087
        this_line = [' ' for i in range(num_cols)]
2757
1088
        next_line = [' ' for i in range(num_cols)]
2758
1089
        
2759
1090
        for start, end, color, direct in lines:
2760
1091
            if start is None or end is None:
2761
1092
                continue
2762
1093
            start = int(round(start))
2763
1094
            end = int(round(end))
2764
1095
            if start == end:
2765
1096
                this_line[start * 2] = ver_char[direct]
2766
1097
                next_line[start * 2] = ver_char[direct]
2767
1098
            else:
2768
1099
                this_line[start * 2] = ver_char[direct]
2769
1100
        
2770
1101
        def replace_char(line, i, char_dict):
2771
1102
            old_char = line[i]
2772
1103
            if old_char in char_dict:
2773
1104
                line[i] = char_dict[old_char]
2774
1105
            
2775
1106
        for start, end, color, direct in lines:
2776
1107
            if start is None or end is None:
2777
1108
                continue
2778
1109
            start = int(round(start))
2779
1110
            end = int(round(end))
2780
1111
            if start < end:
2781
1112
                for i in range(start * 2 + 1, end * 2):
2782
1113
                    replace_char(next_line, i, hor_char[direct])
2783
1114
                replace_char(next_line, start * 2, bl_char)
2784
1115
                replace_char(next_line, end * 2, tr_char)
2785
1116
            elif start > end:
2786
1117
                for i in range(end * 2 + 1, start * 2):
2787
1118
                    replace_char(next_line, i, hor_char[direct])
2788
1119
                replace_char(next_line, start * 2, br_char)
2789
1120
                replace_char(next_line, end * 2, tl_char)
2790
1121
        
2791
1122
        this_line[int(col_index * 2)] = twisty_char[twisty_state]
2792
1123
        
2793
1124
        s.write(''.join(this_line))
2794
1125
        s.write('\n')
2795
1126
        
2796
1127
        if not row == len(list)-1:
2797
1128
            s.write('# '.rjust(repr_width + 5))
2798
1129
            s.write(''.join(next_line))
2799
1130
            s.write('\n')
2800
1131
    return s.getvalue()
2801
1132
2802
1133
2803
1134
class TestGroupOverlapping(TestCase):
2804
1135
    def test_group_overlapping(self):
2805
1136
        lines = [
2806
1137
            (['a1'], 1, 3, 'a'),
2807
1138
            (['a2'], 2, 5, 'a'),
2808
1139
            (['a3'], 4, 6, 'a'),
2809
1140
            (['a4'], 6, 8, 'a'),
2810
1141
            (['b1'], 1, 3, 'b'),
2811
1142
            (['b2'], 2, 5, 'b'),
2812
1143
            (['n1'], 1, 8, None),
2813
1144
            (['n2'], 1, 8, None),
2814
1145
            ]
2815
1146
        groups = loggraphviz.group_overlapping(lines)
2816
1147
        self.assertEqual(
2817
1148
            [(['a1', 'a2', 'a3'], 1, 6, 'a'),
2818
1149
             (['a4'], 6, 8, 'a'),
2819
1150
             (['b1', 'b2'], 1, 5, 'b'),
2820
1151
             (['n1'], 1, 8, None),
2821
1152
             (['n2'], 1, 8, None)],
2822
1153
            groups)
Status:	Work in progress
Proposed branch:	lp:~garyvdm/bzr/loggraphviz
Merge into:	lp:bzr
Diff against target:	2822 lines (+2802/-0) 3 files modified bzrlib/loggraphviz.py (+1648/-0) bzrlib/tests/__init__.py (+1/-0) bzrlib/tests/test_loggraphviz.py (+1153/-0)
To merge this branch:	bzr merge lp:~garyvdm/bzr/loggraphviz
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
bzr-core		2010-11-18	Pending
Review via email: mp+41146@code.launchpad.net