/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/log.py

merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/log.py
188
188
    finally:
189
189
        branch.unlock()
190
190
 
 
191
 
191
192
def _show_log(branch,
192
193
             lf,
193
194
             specific_fileid=None,
203
204
 
204
205
    if specific_fileid:
205
206
        mutter('get log for file_id %r', specific_fileid)
206
 
 
 
207
    generate_merge_revisions = getattr(lf, 'supports_merge_revisions', False)
 
208
    allow_single_merge_revision = getattr(lf,
 
209
        'supports_single_merge_revision', False)
 
210
    view_revisions = calculate_view_revisions(branch, start_revision,
 
211
                                              end_revision, direction,
 
212
                                              specific_fileid,
 
213
                                              generate_merge_revisions,
 
214
                                              allow_single_merge_revision)
207
215
    if search is not None:
208
216
        searchRE = re.compile(search, re.IGNORECASE)
209
217
    else:
210
218
        searchRE = None
211
219
 
 
220
    rev_tag_dict = {}
 
221
    generate_tags = getattr(lf, 'supports_tags', False)
 
222
    if generate_tags:
 
223
        if branch.supports_tags():
 
224
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
 
225
 
 
226
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
 
227
 
 
228
    # now we just print all the revisions
 
229
    log_count = 0
 
230
    for (rev_id, revno, merge_depth), rev, delta in _iter_revisions(
 
231
        branch.repository, view_revisions, generate_delta):
 
232
        if searchRE:
 
233
            if not searchRE.search(rev.message):
 
234
                continue
 
235
 
 
236
        lr = LogRevision(rev, revno, merge_depth, delta,
 
237
                         rev_tag_dict.get(rev_id))
 
238
        lf.log_revision(lr)
 
239
        if limit:
 
240
            log_count += 1
 
241
            if log_count >= limit:
 
242
                break
 
243
 
 
244
 
 
245
def calculate_view_revisions(branch, start_revision, end_revision, direction,
 
246
                             specific_fileid, generate_merge_revisions,
 
247
                             allow_single_merge_revision):
 
248
    if (not generate_merge_revisions and start_revision is end_revision is
 
249
        None and direction == 'reverse' and specific_fileid is None):
 
250
        return _linear_view_revisions(branch)
 
251
 
212
252
    mainline_revs, rev_nos, start_rev_id, end_rev_id = \
213
253
        _get_mainline_revs(branch, start_revision, end_revision)
214
254
    if not mainline_revs:
215
 
        return
 
255
        return []
216
256
 
217
257
    if direction == 'reverse':
218
258
        start_rev_id, end_rev_id = end_rev_id, start_rev_id
219
 
        
220
 
    generate_merge_revisions = getattr(lf, 'supports_merge_revisions', False)
 
259
 
221
260
    generate_single_revision = False
222
261
    if ((not generate_merge_revisions)
223
262
        and ((start_rev_id and (start_rev_id not in rev_nos))
224
263
            or (end_rev_id and (end_rev_id not in rev_nos)))):
225
264
        generate_single_revision = ((start_rev_id == end_rev_id)
226
 
            and getattr(lf, 'supports_single_merge_revision', False))
 
265
            and allow_single_merge_revision)
227
266
        if not generate_single_revision:
228
267
            raise BzrCommandError('Selected log formatter only supports '
229
268
                'mainline revisions.')
247
286
        min_depth = min([d for r,n,d in view_revisions])
248
287
        if min_depth != 0:
249
288
            view_revisions = [(r,n,d-min_depth) for r,n,d in view_revisions]
250
 
        
251
 
    rev_tag_dict = {}
252
 
    generate_tags = getattr(lf, 'supports_tags', False)
253
 
    if generate_tags:
254
 
        if branch.supports_tags():
255
 
            rev_tag_dict = branch.tags.get_reverse_tag_dict()
256
 
 
257
 
    generate_delta = verbose and getattr(lf, 'supports_delta', False)
258
 
 
259
 
    def iter_revisions():
 
289
    return view_revisions
 
290
 
 
291
 
 
292
def _linear_view_revisions(branch):
 
293
    start_revno, start_revision_id = branch.last_revision_info()
 
294
    repo = branch.repository
 
295
    revision_ids = repo.iter_reverse_revision_history(start_revision_id)
 
296
    for num, revision_id in enumerate(revision_ids):
 
297
        yield revision_id, str(start_revno - num), 0
 
298
 
 
299
 
 
300
def _iter_revisions(repository, view_revisions, generate_delta):
 
301
    num = 9
 
302
    view_revisions = iter(view_revisions)
 
303
    while True:
 
304
        cur_view_revisions = [d for x, d in zip(range(num), view_revisions)]
 
305
        if len(cur_view_revisions) == 0:
 
306
            break
 
307
        cur_deltas = {}
260
308
        # r = revision, n = revno, d = merge depth
261
 
        revision_ids = [r for r, n, d in view_revisions]
262
 
        num = 9
263
 
        repository = branch.repository
264
 
        while revision_ids:
265
 
            cur_deltas = {}
266
 
            revisions = repository.get_revisions(revision_ids[:num])
267
 
            if generate_delta:
268
 
                deltas = repository.get_deltas_for_revisions(revisions)
269
 
                cur_deltas = dict(izip((r.revision_id for r in revisions),
270
 
                                       deltas))
271
 
            for revision in revisions:
272
 
                yield revision, cur_deltas.get(revision.revision_id)
273
 
            revision_ids  = revision_ids[num:]
274
 
            num = min(int(num * 1.5), 200)
275
 
 
276
 
    # now we just print all the revisions
277
 
    log_count = 0
278
 
    for ((rev_id, revno, merge_depth), (rev, delta)) in \
279
 
         izip(view_revisions, iter_revisions()):
280
 
 
281
 
        if searchRE:
282
 
            if not searchRE.search(rev.message):
283
 
                continue
284
 
 
285
 
        lr = LogRevision(rev, revno, merge_depth, delta,
286
 
                         rev_tag_dict.get(rev_id))
287
 
        lf.log_revision(lr)
288
 
        if limit:
289
 
            log_count += 1
290
 
            if log_count >= limit:
291
 
                break
 
309
        revision_ids = [r for (r, n, d) in cur_view_revisions]
 
310
        revisions = repository.get_revisions(revision_ids)
 
311
        if generate_delta:
 
312
            deltas = repository.get_deltas_for_revisions(revisions)
 
313
            cur_deltas = dict(izip((r.revision_id for r in revisions),
 
314
                                   deltas))
 
315
        for view_data, revision in izip(cur_view_revisions, revisions):
 
316
            yield view_data, revision, cur_deltas.get(revision.revision_id)
 
317
        num = min(int(num * 1.5), 200)
292
318
 
293
319
 
294
320
def _get_mainline_revs(branch, start_revision, end_revision):