/b-gtk/fix-viz

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/b-gtk/fix-viz

« back to all changes in this revision

Viewing changes to branchview/linegraph.py

  • Committer: Chad MILLER
  • Date: 2008-05-01 14:09:49 UTC
  • mto: (511.5.3 trunk)
  • mto: This revision was merged to the branch mainline in revision 519.
  • Revision ID: chad@mysql.com-20080501140949-zg3vgni13mi8qojr
Big diff, few changes.  :(  

Wrap sub-progress bars in try/finally to ensure they're cleaned up.  

Make the root progress bar optional.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branchview/linegraph.py
13
13
from bzrlib.tsort import merge_sort
14
14
from bzrlib import ui
15
15
 
16
 
 
17
 
def linegraph(repository, start_revs, maxnum, root_progress, 
18
 
              broken_line_length = None, graph_data = True,
19
 
              mainline_only = False):
 
16
def linegraph(repository, start_revs, maxnum, broken_line_length = None,
 
17
              graph_data = True, mainline_only = False, root_progress = None):
20
18
    """Produce a directed graph of a bzr repository.
21
19
 
22
20
    Returns a tuple of (line_graph, revid_index, columns_len) where
45
43
    It's up to you how to actually draw the nodes and lines (straight,
46
44
    curved, kinked, etc.) and to pick the actual colours for each index.
47
45
    """
48
 
    
 
46
 
 
47
    def update_root_progress(step_number):
 
48
        """IFF our container received a root progress bar, then update it."""
 
49
        if root_progress is not None:
 
50
            root_progress.update(current=step_number)
 
51
 
49
52
    graph = repository.get_graph()
50
53
    graph_parents = {}
51
54
    ghosts = set()
52
55
    graph_children = {}
53
 
    root_progress.update(current=1)
54
 
    progress_bar = ui.ui_factory.nested_progress_bar()
55
 
    progress_bar.update(msg="Arranging tree fragments")
56
 
    for i, (revid, parent_revids) in enumerate(graph.iter_ancestry(start_revs)):
57
 
        if i % 25 == 0:
58
 
            progress_bar.tick()
59
 
 
60
 
        if parent_revids is None:
61
 
            ghosts.add(revid)
62
 
            continue
63
 
        if parent_revids == (NULL_REVISION,):
64
 
            graph_parents[revid] = ()
65
 
        else:
66
 
            graph_parents[revid] = parent_revids
67
 
        for parent in parent_revids:
68
 
            graph_children.setdefault(parent, []).append(revid)
69
 
        graph_children[revid] = []
70
 
    progress_bar.finished()
71
 
 
72
 
    root_progress.update(current=2)
73
 
    progress_bar = ui.ui_factory.nested_progress_bar()
74
 
    progress_bar.update(msg="Removing ghosts", total=len(ghosts))
75
 
    for i, ghost in enumerate(ghosts):
76
 
        if i % 25 == 0:
77
 
            progress_bar.update(current=i)
78
 
        for ghost_child in graph_children[ghost]:
79
 
            graph_parents[ghost_child] = [p for p in graph_parents[ghost_child]
80
 
                                          if p not in ghosts]
81
 
    progress_bar.finished()
 
56
    update_root_progress(1)
 
57
    progress_bar = ui.ui_factory.nested_progress_bar()
 
58
    try:
 
59
        progress_bar.update(msg="Arranging tree fragments")
 
60
        for i, (revid, parent_revids) in enumerate(graph.iter_ancestry(start_revs)):
 
61
            if i % 25 == 0:
 
62
                progress_bar.tick()
 
63
 
 
64
            if parent_revids is None:
 
65
                ghosts.add(revid)
 
66
                continue
 
67
            if parent_revids == (NULL_REVISION,):
 
68
                graph_parents[revid] = ()
 
69
            else:
 
70
                graph_parents[revid] = parent_revids
 
71
            for parent in parent_revids:
 
72
                graph_children.setdefault(parent, []).append(revid)
 
73
            graph_children[revid] = []
 
74
    finally:
 
75
        progress_bar.finished()
 
76
 
 
77
    update_root_progress(2)
 
78
    progress_bar = ui.ui_factory.nested_progress_bar()
 
79
    try:
 
80
        progress_bar.update(msg="Removing ghosts", total=len(ghosts))
 
81
        for i, ghost in enumerate(ghosts):
 
82
            if i % 25 == 0:
 
83
                progress_bar.update(current=i)
 
84
            for ghost_child in graph_children[ghost]:
 
85
                graph_parents[ghost_child] = [p for p in graph_parents[ghost_child]
 
86
                                              if p not in ghosts]
 
87
    finally:
 
88
        progress_bar.finished()
82
89
    graph_parents["top:"] = start_revs
83
90
 
84
91
    if len(graph_parents)>0:
110
117
    
111
118
    linegraph = []    
112
119
    
113
 
    root_progress.update(current=3)
 
120
    update_root_progress(3)
114
121
    progress_bar = ui.ui_factory.nested_progress_bar()
115
 
    progress_bar.update(msg="Finding nodes", total=len(merge_sorted_revisions))
116
 
    for (rev_index, (sequence_number,
117
 
                     revid,
118
 
                     merge_depth,
119
 
                     revno_sequence,
120
 
                     end_of_merge)) in enumerate(merge_sorted_revisions):
 
122
    try:
 
123
        progress_bar.update(msg="Finding nodes", total=len(merge_sorted_revisions))
 
124
        for (rev_index, (sequence_number,
 
125
                         revid,
 
126
                         merge_depth,
 
127
                         revno_sequence,
 
128
                         end_of_merge)) in enumerate(merge_sorted_revisions):
121
129
 
122
 
        if rev_index % 25 == 0:
123
 
            progress_bar.update(current=rev_index)
124
 
        if maxnum and rev_index >= maxnum:
125
 
            break
126
 
        revid_index[revid] = rev_index
127
 
        
128
 
        parents = graph_parents[revid]
129
 
        linegraph.append([revid,
130
 
                          None,
131
 
                          [],
132
 
                          parents,
133
 
                          None,
134
 
                          revno_sequence])
135
 
        
136
 
        if graph_data:
137
 
            revno_index[revno_sequence] = rev_index
138
 
            
139
 
            branch_id = revno_sequence[0:-1]
140
 
            
141
 
            branch_line = None
142
 
            if branch_id not in branch_lines:
143
 
                branch_line = []
144
 
                branch_lines[branch_id] = branch_line
145
 
            else:
146
 
                branch_line = branch_lines[branch_id]
147
 
            
148
 
            branch_line.append(rev_index)        
149
 
    progress_bar.finished()
 
130
            if rev_index % 25 == 0:
 
131
                progress_bar.update(current=rev_index)
 
132
            if maxnum and rev_index >= maxnum:
 
133
                break
 
134
            revid_index[revid] = rev_index
 
135
            
 
136
            parents = graph_parents[revid]
 
137
            linegraph.append([revid,
 
138
                              None,
 
139
                              [],
 
140
                              parents,
 
141
                              None,
 
142
                              revno_sequence])
 
143
            
 
144
            if graph_data:
 
145
                revno_index[revno_sequence] = rev_index
 
146
                
 
147
                branch_id = revno_sequence[0:-1]
 
148
                
 
149
                branch_line = None
 
150
                if branch_id not in branch_lines:
 
151
                    branch_line = []
 
152
                    branch_lines[branch_id] = branch_line
 
153
                else:
 
154
                    branch_line = branch_lines[branch_id]
 
155
                
 
156
                branch_line.append(rev_index)        
 
157
    finally:
 
158
        progress_bar.finished()
150
159
 
151
160
    if graph_data:
152
161
        branch_ids = branch_lines.keys()
174
183
        columns = [list(empty_column)]
175
184
        
176
185
        
177
 
        root_progress.update(current=4)
 
186
        update_root_progress(4)
178
187
        progress_bar = ui.ui_factory.nested_progress_bar()
179
 
        progress_bar.update(msg="Organizing edges", total=len(branch_ids))
180
 
        for i, branch_id in enumerate(branch_ids):
181
 
            if i % 25 == 0:
182
 
                progress_bar.update(current=i)
183
 
            branch_line = branch_lines[branch_id]
184
 
            
185
 
            # Find the col_index for the direct parent branch. This will be the
186
 
            # starting point when looking for a free column.
187
 
            parent_col_index = 0
188
 
            parent_index = None
189
 
            if len(branch_id) > 1:
190
 
                parent_revno = branch_id[0:-1]
191
 
                if parent_revno in revno_index:
192
 
                    parent_index = revno_index[parent_revno]
193
 
                    parent_node = linegraph[parent_index][1]
194
 
                    if parent_node:
195
 
                        parent_col_index = parent_node[0]
196
 
                    
197
 
            
198
 
            col_search_order = _branch_line_col_search_order(columns,
199
 
                                                             parent_col_index)
200
 
            color = reduce(lambda x, y: x+y, branch_id, 0)
201
 
            cur_cont_line = []
202
 
            
203
 
            line_range = []
204
 
            last_rev_index = None
205
 
            for rev_index in branch_line:
206
 
                if last_rev_index:
207
 
                    if broken_line_length and \
208
 
                       rev_index - last_rev_index > broken_line_length:
209
 
                        line_range.append(last_rev_index+1)
210
 
                        line_range.append(rev_index-1)
211
 
                    else:
212
 
                        line_range.extend(range(last_rev_index+1, rev_index))
213
 
                
214
 
                line_range.append(rev_index)
215
 
                last_rev_index = rev_index
216
 
            
217
 
            if parent_index:
218
 
                if broken_line_length and \
219
 
                   parent_index - last_rev_index > broken_line_length:
220
 
                    line_range.append(last_rev_index+1)
221
 
                else:
222
 
                    line_range.extend(range(last_rev_index+1, parent_index))
223
 
            
224
 
            col_index = _find_free_column(columns,
225
 
                                          empty_column,
226
 
                                          col_search_order,
227
 
                                          line_range)
228
 
            node = (col_index, color)
229
 
            for rev_index in branch_line:
230
 
                linegraph[rev_index][1] = node
231
 
                columns[col_index][rev_index] = True
232
 
            
233
 
            for rev_index in branch_line:
234
 
                (sequence_number,
235
 
                     revid,
236
 
                     merge_depth,
237
 
                     revno_sequence,
238
 
                     end_of_merge) = merge_sorted_revisions[rev_index]
239
 
                
240
 
                linegraph[rev_index][4] = graph_children[revid]
241
 
                col_index = linegraph[rev_index][1][0]
242
 
                
243
 
                for parent_revid in graph_parents[revid]:
244
 
                    if parent_revid in revid_index:
245
 
                        
246
 
                        parent_index = revid_index[parent_revid]                            
 
188
        try:
 
189
            progress_bar.update(msg="Organizing edges", total=len(branch_ids))
 
190
            for i, branch_id in enumerate(branch_ids):
 
191
                if i % 25 == 0:
 
192
                    progress_bar.update(current=i)
 
193
                branch_line = branch_lines[branch_id]
 
194
                
 
195
                # Find the col_index for the direct parent branch. This will be the
 
196
                # starting point when looking for a free column.
 
197
                parent_col_index = 0
 
198
                parent_index = None
 
199
                if len(branch_id) > 1:
 
200
                    parent_revno = branch_id[0:-1]
 
201
                    if parent_revno in revno_index:
 
202
                        parent_index = revno_index[parent_revno]
247
203
                        parent_node = linegraph[parent_index][1]
248
204
                        if parent_node:
249
205
                            parent_col_index = parent_node[0]
 
206
                        
 
207
                
 
208
                col_search_order = _branch_line_col_search_order(columns,
 
209
                                                                 parent_col_index)
 
210
                color = reduce(lambda x, y: x+y, branch_id, 0)
 
211
                cur_cont_line = []
 
212
                
 
213
                line_range = []
 
214
                last_rev_index = None
 
215
                for rev_index in branch_line:
 
216
                    if last_rev_index:
 
217
                        if broken_line_length and \
 
218
                           rev_index - last_rev_index > broken_line_length:
 
219
                            line_range.append(last_rev_index+1)
 
220
                            line_range.append(rev_index-1)
250
221
                        else:
251
 
                            parent_col_index = None
252
 
                        col_search_order = \
253
 
                                _line_col_search_order(columns,
254
 
                                                       parent_col_index,
255
 
                                                       col_index)
256
 
                            
257
 
                        # If this line is really long, break it.
258
 
                        if len(branch_id) > 0 and \
259
 
                           broken_line_length and \
260
 
                           parent_index - rev_index > broken_line_length:
261
 
                            child_line_col_index = \
262
 
                                _find_free_column(columns,
263
 
                                                  empty_column,
264
 
                                                  col_search_order,
265
 
                                                  (rev_index + 1,))
266
 
                            _mark_column_as_used(columns,
267
 
                                                 child_line_col_index,
268
 
                                                 (rev_index + 1,))
269
 
                            
270
 
                            # Recall _line_col_search_order to reset it back to
271
 
                            # the beging.
 
222
                            line_range.extend(range(last_rev_index+1, rev_index))
 
223
                    
 
224
                    line_range.append(rev_index)
 
225
                    last_rev_index = rev_index
 
226
                
 
227
                if parent_index:
 
228
                    if broken_line_length and \
 
229
                       parent_index - last_rev_index > broken_line_length:
 
230
                        line_range.append(last_rev_index+1)
 
231
                    else:
 
232
                        line_range.extend(range(last_rev_index+1, parent_index))
 
233
                
 
234
                col_index = _find_free_column(columns,
 
235
                                              empty_column,
 
236
                                              col_search_order,
 
237
                                              line_range)
 
238
                node = (col_index, color)
 
239
                for rev_index in branch_line:
 
240
                    linegraph[rev_index][1] = node
 
241
                    columns[col_index][rev_index] = True
 
242
                
 
243
                for rev_index in branch_line:
 
244
                    (sequence_number,
 
245
                         revid,
 
246
                         merge_depth,
 
247
                         revno_sequence,
 
248
                         end_of_merge) = merge_sorted_revisions[rev_index]
 
249
                    
 
250
                    linegraph[rev_index][4] = graph_children[revid]
 
251
                    col_index = linegraph[rev_index][1][0]
 
252
                    
 
253
                    for parent_revid in graph_parents[revid]:
 
254
                        if parent_revid in revid_index:
 
255
                            
 
256
                            parent_index = revid_index[parent_revid]                            
 
257
                            parent_node = linegraph[parent_index][1]
 
258
                            if parent_node:
 
259
                                parent_col_index = parent_node[0]
 
260
                            else:
 
261
                                parent_col_index = None
272
262
                            col_search_order = \
273
263
                                    _line_col_search_order(columns,
274
264
                                                           parent_col_index,
275
265
                                                           col_index)
276
 
                            parent_col_line_index = \
277
 
                                _find_free_column(columns,
278
 
                                                  empty_column,
279
 
                                                  col_search_order,
280
 
                                                  (parent_index - 1,))
281
 
                            _mark_column_as_used(columns,
282
 
                                                 parent_col_line_index,
283
 
                                                 (parent_index - 1,))
284
 
                            lines.append((rev_index,
285
 
                                          parent_index,
286
 
                                          (child_line_col_index,
287
 
                                           parent_col_line_index)))
288
 
                        else :
289
 
                            line_col_index = col_index
290
 
                            if parent_index - rev_index >1:
291
 
                                line_range = range(rev_index + 1, parent_index)
292
 
                                line_col_index = \
293
 
                                    _find_free_column(columns,
294
 
                                                      empty_column,
295
 
                                                      col_search_order,
296
 
                                                      line_range)
297
 
                                _mark_column_as_used(columns,
298
 
                                                     line_col_index,
299
 
                                                     line_range)
300
 
                            lines.append((rev_index,
301
 
                                          parent_index,
302
 
                                          (line_col_index,)))
303
 
        progress_bar.finished()
 
266
                                
 
267
                            # If this line is really long, break it.
 
268
                            if len(branch_id) > 0 and \
 
269
                               broken_line_length and \
 
270
                               parent_index - rev_index > broken_line_length:
 
271
                                child_line_col_index = \
 
272
                                    _find_free_column(columns,
 
273
                                                      empty_column,
 
274
                                                      col_search_order,
 
275
                                                      (rev_index + 1,))
 
276
                                _mark_column_as_used(columns,
 
277
                                                     child_line_col_index,
 
278
                                                     (rev_index + 1,))
 
279
                                
 
280
                                # Recall _line_col_search_order to reset it back to
 
281
                                # the beging.
 
282
                                col_search_order = \
 
283
                                        _line_col_search_order(columns,
 
284
                                                               parent_col_index,
 
285
                                                               col_index)
 
286
                                parent_col_line_index = \
 
287
                                    _find_free_column(columns,
 
288
                                                      empty_column,
 
289
                                                      col_search_order,
 
290
                                                      (parent_index - 1,))
 
291
                                _mark_column_as_used(columns,
 
292
                                                     parent_col_line_index,
 
293
                                                     (parent_index - 1,))
 
294
                                lines.append((rev_index,
 
295
                                              parent_index,
 
296
                                              (child_line_col_index,
 
297
                                               parent_col_line_index)))
 
298
                            else :
 
299
                                line_col_index = col_index
 
300
                                if parent_index - rev_index >1:
 
301
                                    line_range = range(rev_index + 1, parent_index)
 
302
                                    line_col_index = \
 
303
                                        _find_free_column(columns,
 
304
                                                          empty_column,
 
305
                                                          col_search_order,
 
306
                                                          line_range)
 
307
                                    _mark_column_as_used(columns,
 
308
                                                         line_col_index,
 
309
                                                         line_range)
 
310
                                lines.append((rev_index,
 
311
                                              parent_index,
 
312
                                              (line_col_index,)))
 
313
        finally:
 
314
            progress_bar.finished()
304
315
        
305
 
        root_progress.update(current=5)
 
316
        update_root_progress(5)
306
317
        progress_bar = ui.ui_factory.nested_progress_bar()
307
 
        progress_bar.update(msg="Pretifying graph", total=len(lines))
308
 
        for i, (child_index, parent_index, line_col_indexes) in enumerate(lines):
309
 
            if i % 25 == 0:
310
 
                progress_bar.update(current=i)
311
 
            (child_col_index, child_color) = linegraph[child_index][1]
312
 
            (parent_col_index, parent_color) = linegraph[parent_index][1]
313
 
            
314
 
            if len(line_col_indexes) == 1:
315
 
                if parent_index - child_index == 1:
316
 
                    linegraph[child_index][2].append(
317
 
                        (child_col_index,
318
 
                         parent_col_index,
319
 
                         parent_color))
 
318
        try:
 
319
            progress_bar.update(msg="Pretifying graph", total=len(lines))
 
320
            for i, (child_index, parent_index, line_col_indexes) in enumerate(lines):
 
321
                if i % 25 == 0:
 
322
                    progress_bar.update(current=i)
 
323
                (child_col_index, child_color) = linegraph[child_index][1]
 
324
                (parent_col_index, parent_color) = linegraph[parent_index][1]
 
325
                
 
326
                if len(line_col_indexes) == 1:
 
327
                    if parent_index - child_index == 1:
 
328
                        linegraph[child_index][2].append(
 
329
                            (child_col_index,
 
330
                             parent_col_index,
 
331
                             parent_color))
 
332
                    else:
 
333
                        # line from the child's column to the lines column
 
334
                        linegraph[child_index][2].append(
 
335
                            (child_col_index,
 
336
                             line_col_indexes[0],
 
337
                             parent_color))
 
338
                        # lines down the line's column
 
339
                        for line_part_index in range(child_index+1, parent_index-1):
 
340
                            linegraph[line_part_index][2].append(
 
341
                                (line_col_indexes[0],   
 
342
                                 line_col_indexes[0],
 
343
                                 parent_color))
 
344
                        # line from the line's column to the parent's column
 
345
                        linegraph[parent_index-1][2].append(
 
346
                            (line_col_indexes[0],
 
347
                             parent_col_index,
 
348
                             parent_color))
320
349
                else:
 
350
                    # Broken line
321
351
                    # line from the child's column to the lines column
322
352
                    linegraph[child_index][2].append(
323
353
                        (child_col_index,
324
354
                         line_col_indexes[0],
325
355
                         parent_color))
326
 
                    # lines down the line's column
327
 
                    for line_part_index in range(child_index+1, parent_index-1):
328
 
                        linegraph[line_part_index][2].append(
329
 
                            (line_col_indexes[0],   
330
 
                             line_col_indexes[0],
331
 
                             parent_color))
 
356
                    # Broken line end
 
357
                    linegraph[child_index+1][2].append(
 
358
                        (line_col_indexes[0],
 
359
                         None,
 
360
                         parent_color))
 
361
                    
 
362
                    # Broken line end 
 
363
                    linegraph[parent_index-2][2].append(
 
364
                        (None,
 
365
                         line_col_indexes[1],
 
366
                         parent_color))
332
367
                    # line from the line's column to the parent's column
333
368
                    linegraph[parent_index-1][2].append(
334
 
                        (line_col_indexes[0],
 
369
                        (line_col_indexes[1],
335
370
                         parent_col_index,
336
371
                         parent_color))
337
 
            else:
338
 
                # Broken line
339
 
                # line from the child's column to the lines column
340
 
                linegraph[child_index][2].append(
341
 
                    (child_col_index,
342
 
                     line_col_indexes[0],
343
 
                     parent_color))
344
 
                # Broken line end
345
 
                linegraph[child_index+1][2].append(
346
 
                    (line_col_indexes[0],
347
 
                     None,
348
 
                     parent_color))
349
 
                
350
 
                # Broken line end 
351
 
                linegraph[parent_index-2][2].append(
352
 
                    (None,
353
 
                     line_col_indexes[1],
354
 
                     parent_color))
355
 
                # line from the line's column to the parent's column
356
 
                linegraph[parent_index-1][2].append(
357
 
                    (line_col_indexes[1],
358
 
                     parent_col_index,
359
 
                     parent_color))
360
 
        progress_bar.finished()
 
372
        finally:
 
373
            progress_bar.finished()
361
374
        return (linegraph, revid_index, len(columns))
362
375
    else:
363
376
        return (linegraph, revid_index, 0)