174
181
:param show_diff: If True, output a diff after each revision.
178
if getattr(lf, 'begin_log', None):
181
_show_log(branch, lf, specific_fileid, verbose, direction,
182
start_revision, end_revision, search, limit, show_diff)
184
if getattr(lf, 'end_log', None):
190
def _show_log(branch,
192
specific_fileid=None,
200
"""Worker function for show_log - see show_log."""
201
if not isinstance(lf, LogFormatter):
202
warn("not a LogFormatter instance: %r" % lf)
204
trace.mutter('get log for file_id %r', specific_fileid)
206
# Consult the LogFormatter about what it needs and can handle
207
levels_to_display = lf.get_levels()
208
generate_merge_revisions = levels_to_display != 1
209
allow_single_merge_revision = True
210
if not getattr(lf, 'supports_merge_revisions', False):
211
allow_single_merge_revision = getattr(lf,
212
'supports_single_merge_revision', False)
213
generate_tags = getattr(lf, 'supports_tags', False)
214
if generate_tags and branch.supports_tags():
215
rev_tag_dict = branch.tags.get_reverse_tag_dict()
218
generate_delta = verbose and getattr(lf, 'supports_delta', False)
219
generate_diff = show_diff and getattr(lf, 'supports_diff', False)
221
# Find and print the interesting revisions
222
repo = branch.repository
224
revision_iterator = _create_log_revision_iterator(branch,
225
start_revision, end_revision, direction, specific_fileid, search,
226
generate_merge_revisions, allow_single_merge_revision,
227
generate_delta, limited_output=limit > 0)
228
for revs in revision_iterator:
229
for (rev_id, revno, merge_depth), rev, delta in revs:
230
# Note: 0 levels means show everything; merge_depth counts from 0
231
if levels_to_display != 0 and merge_depth >= levels_to_display:
234
diff = _format_diff(repo, rev, rev_id, specific_fileid)
237
lr = LogRevision(rev, revno, merge_depth, delta,
238
rev_tag_dict.get(rev_id), diff)
183
# Convert old-style parameters to new-style parameters
184
if specific_fileid is not None:
185
file_ids = [specific_fileid]
190
delta_type = 'partial'
197
diff_type = 'partial'
203
# Build the request and execute it
204
rqst = make_log_request_dict(direction=direction, specific_fileids=file_ids,
205
start_revision=start_revision, end_revision=end_revision,
206
limit=limit, message_search=search,
207
delta_type=delta_type, diff_type=diff_type)
208
Logger(branch, rqst).show(lf)
211
# Note: This needs to be kept this in sync with the defaults in
212
# make_log_request_dict() below
213
_DEFAULT_REQUEST_PARAMS = {
214
'direction': 'reverse',
216
'generate_tags': True,
217
'_match_using_deltas': True,
221
def make_log_request_dict(direction='reverse', specific_fileids=None,
222
start_revision=None, end_revision=None, limit=None,
223
message_search=None, levels=1, generate_tags=True, delta_type=None,
224
diff_type=None, _match_using_deltas=True):
225
"""Convenience function for making a logging request dictionary.
227
Using this function may make code slightly safer by ensuring
228
parameters have the correct names. It also provides a reference
229
point for documenting the supported parameters.
231
:param direction: 'reverse' (default) is latest to earliest;
232
'forward' is earliest to latest.
234
:param specific_fileids: If not None, only include revisions
235
affecting the specified files, rather than all revisions.
237
:param start_revision: If not None, only generate
238
revisions >= start_revision
240
:param end_revision: If not None, only generate
241
revisions <= end_revision
243
:param limit: If set, generate only 'limit' revisions, all revisions
244
are shown if None or 0.
246
:param message_search: If not None, only include revisions with
247
matching commit messages
249
:param levels: the number of levels of revisions to
250
generate; 1 for just the mainline; 0 for all levels.
252
:param generate_tags: If True, include tags for matched revisions.
254
:param delta_type: Either 'full', 'partial' or None.
255
'full' means generate the complete delta - adds/deletes/modifies/etc;
256
'partial' means filter the delta using specific_fileids;
257
None means do not generate any delta.
259
:param diff_type: Either 'full', 'partial' or None.
260
'full' means generate the complete diff - adds/deletes/modifies/etc;
261
'partial' means filter the diff using specific_fileids;
262
None means do not generate any diff.
264
:param _match_using_deltas: a private parameter controlling the
265
algorithm used for matching specific_fileids. This parameter
266
may be removed in the future so bzrlib client code should NOT
270
'direction': direction,
271
'specific_fileids': specific_fileids,
272
'start_revision': start_revision,
273
'end_revision': end_revision,
275
'message_search': message_search,
277
'generate_tags': generate_tags,
278
'delta_type': delta_type,
279
'diff_type': diff_type,
280
# Add 'private' attributes for features that may be deprecated
281
'_match_using_deltas': _match_using_deltas,
282
'_allow_single_merge_revision': True,
286
def _apply_log_request_defaults(rqst):
287
"""Apply default values to a request dictionary."""
288
result = _DEFAULT_REQUEST_PARAMS
294
class LogGenerator(object):
295
"""A generator of log revisions."""
297
def iter_log_revisions(self):
298
"""Iterate over LogRevision objects.
300
:return: An iterator yielding LogRevision objects.
302
raise NotImplementedError(self.iter_log_revisions)
305
class Logger(object):
306
"""An object the generates, formats and displays a log."""
308
def __init__(self, branch, rqst):
311
:param branch: the branch to log
312
:param rqst: A dictionary specifying the query parameters.
313
See make_log_request_dict() for supported values.
316
self.rqst = _apply_log_request_defaults(rqst)
321
:param lf: The LogFormatter object to send the output to.
323
if not isinstance(lf, LogFormatter):
324
warn("not a LogFormatter instance: %r" % lf)
326
self.branch.lock_read()
328
if getattr(lf, 'begin_log', None):
331
if getattr(lf, 'end_log', None):
336
def _show_body(self, lf):
337
"""Show the main log output.
339
Subclasses may wish to override this.
341
# Tweak the LogRequest based on what the LogFormatter can handle.
342
# (There's no point generating stuff if the formatter can't display it.)
344
rqst['levels'] = lf.get_levels()
345
if not getattr(lf, 'supports_tags', False):
346
rqst['generate_tags'] = False
347
if not getattr(lf, 'supports_delta', False):
348
rqst['delta_type'] = None
349
if not getattr(lf, 'supports_diff', False):
350
rqst['diff_type'] = None
351
if not getattr(lf, 'supports_merge_revisions', False):
352
rqst['_allow_single_merge_revision'] = getattr(lf,
353
'supports_single_merge_revision', False)
355
# Find and print the interesting revisions
356
generator = self._generator_factory(self.branch, rqst)
357
for lr in generator.iter_log_revisions():
239
358
lf.log_revision(lr)
242
if log_count >= limit:
246
def _format_diff(repo, rev, rev_id, specific_fileid):
247
if len(rev.parent_ids) == 0:
248
ancestor_id = _mod_revision.NULL_REVISION
250
ancestor_id = rev.parent_ids[0]
251
tree_1 = repo.revision_tree(ancestor_id)
252
tree_2 = repo.revision_tree(rev_id)
254
specific_files = [tree_2.id2path(specific_fileid)]
256
specific_files = None
258
diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
360
def _generator_factory(self, branch, rqst):
361
"""Make the LogGenerator object to use.
363
Subclasses may wish to override this.
365
return _DefaultLogGenerator(branch, rqst)
263
368
class _StartNotLinearAncestor(Exception):
264
369
"""Raised when a start revision is not found walking left-hand history."""
267
def _create_log_revision_iterator(branch, start_revision, end_revision,
268
direction, specific_fileid, search, generate_merge_revisions,
269
allow_single_merge_revision, generate_delta, limited_output=False):
270
"""Create a revision iterator for log.
272
:param branch: The branch being logged.
273
:param start_revision: If not None, only show revisions >= start_revision
274
:param end_revision: If not None, only show revisions <= end_revision
275
:param direction: 'reverse' (default) is latest to earliest; 'forward' is
277
:param specific_fileid: If not None, list only the commits affecting the
279
:param search: If not None, only show revisions with matching commit
281
:param generate_merge_revisions: If False, show only mainline revisions.
282
:param allow_single_merge_revision: If True, logging of a single
283
revision off the mainline is to be allowed
284
:param generate_delta: Whether to generate a delta for each revision.
285
:param limited_output: if True, the user only wants a limited result
287
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
290
start_rev_id, end_rev_id = _get_revision_limits(branch, start_revision,
293
# Decide how file-ids are matched: delta-filtering vs per-file graph.
294
# Delta filtering allows revisions to be displayed incrementally
295
# though the total time is much slower for huge repositories: log -v
296
# is the *lower* performance bound. At least until the split
297
# inventory format arrives, per-file-graph needs to remain the
298
# default except in verbose mode. Delta filtering should give more
299
# accurate results (e.g. inclusion of FILE deletions) so arguably
300
# it should always be used in the future.
301
use_deltas_for_matching = specific_fileid and generate_delta
302
delayed_graph_generation = not specific_fileid and (
303
start_rev_id or end_rev_id or limited_output)
304
generate_merges = generate_merge_revisions or (specific_fileid and
305
not use_deltas_for_matching)
306
view_revisions = _calc_view_revisions(branch, start_rev_id, end_rev_id,
307
direction, generate_merges, allow_single_merge_revision,
308
delayed_graph_generation=delayed_graph_generation)
309
search_deltas_for_fileids = None
310
if use_deltas_for_matching:
311
search_deltas_for_fileids = set([specific_fileid])
312
elif specific_fileid:
372
class _DefaultLogGenerator(LogGenerator):
373
"""The default generator of log revisions."""
375
def __init__(self, branch, rqst):
378
if rqst.get('generate_tags') and branch.supports_tags():
379
self.rev_tag_dict = branch.tags.get_reverse_tag_dict()
381
self.rev_tag_dict = {}
383
def iter_log_revisions(self):
384
"""Iterate over LogRevision objects.
386
:return: An iterator yielding LogRevision objects.
390
revision_iterator = self._create_log_revision_iterator()
391
for revs in revision_iterator:
392
for (rev_id, revno, merge_depth), rev, delta in revs:
393
# 0 levels means show everything; merge_depth counts from 0
394
levels = rqst.get('levels')
395
if levels != 0 and merge_depth >= levels:
397
diff = self._format_diff(rev, rev_id)
398
yield LogRevision(rev, revno, merge_depth, delta,
399
self.rev_tag_dict.get(rev_id), diff)
400
limit = rqst.get('limit')
403
if log_count >= limit:
406
def _format_diff(self, rev, rev_id):
407
diff_type = self.rqst.get('diff_type')
408
if diff_type is None:
410
repo = self.branch.repository
411
if len(rev.parent_ids) == 0:
412
ancestor_id = _mod_revision.NULL_REVISION
414
ancestor_id = rev.parent_ids[0]
415
tree_1 = repo.revision_tree(ancestor_id)
416
tree_2 = repo.revision_tree(rev_id)
417
file_ids = self.rqst.get('specific_fileids')
418
if diff_type == 'partial' and file_ids is not None:
419
specific_files = [tree_2.id2path(id) for id in file_ids]
421
specific_files = None
423
diff.show_diff_trees(tree_1, tree_2, s, specific_files, old_label='',
427
def _create_log_revision_iterator(self):
428
"""Create a revision iterator for log.
430
:return: An iterator over lists of ((rev_id, revno, merge_depth), rev,
433
self.start_rev_id, self.end_rev_id = _get_revision_limits(
434
self.branch, self.rqst.get('start_revision'),
435
self.rqst.get('end_revision'))
436
if self.rqst.get('_match_using_deltas'):
437
return self._log_revision_iterator_using_delta_matching()
439
# We're using the per-file-graph algorithm. This scales really
440
# well but only makes sense if there is a single file and it's
442
file_count = len(self.rqst.get('specific_fileids'))
444
raise BzrError("illegal LogRequest: must match-using-deltas "
445
"when logging %d files" % file_count)
446
return self._log_revision_iterator_using_per_file_graph()
448
def _log_revision_iterator_using_delta_matching(self):
449
# Get the base revisions, filtering by the revision range
451
generate_merge_revisions = rqst.get('levels') != 1
452
delayed_graph_generation = not rqst.get('specific_fileids') and (
453
rqst.get('limit') or self.start_rev_id or self.end_rev_id)
454
view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
455
self.end_rev_id, rqst.get('direction'), generate_merge_revisions,
456
rqst.get('_allow_single_merge_revision'),
457
delayed_graph_generation=delayed_graph_generation)
459
# Apply the other filters
460
return make_log_rev_iterator(self.branch, view_revisions,
461
rqst.get('delta_type'), rqst.get('message_search'),
462
file_ids=rqst.get('specific_fileids'),
463
direction=rqst.get('direction'))
465
def _log_revision_iterator_using_per_file_graph(self):
466
# Get the base revisions, filtering by the revision range.
467
# Note that we always generate the merge revisions because
468
# filter_revisions_touching_file_id() requires them ...
470
view_revisions = _calc_view_revisions(self.branch, self.start_rev_id,
471
self.end_rev_id, rqst.get('direction'), True,
472
rqst.get('_allow_single_merge_revision'))
313
473
if not isinstance(view_revisions, list):
314
474
view_revisions = list(view_revisions)
315
view_revisions = _filter_revisions_touching_file_id(branch,
316
specific_fileid, view_revisions,
317
include_merges=generate_merge_revisions)
318
return make_log_rev_iterator(branch, view_revisions, generate_delta,
319
search, file_ids=search_deltas_for_fileids, direction=direction)
475
view_revisions = _filter_revisions_touching_file_id(self.branch,
476
rqst.get('specific_fileids')[0], view_revisions,
477
include_merges=rqst.get('levels') != 1)
478
return make_log_rev_iterator(self.branch, view_revisions,
479
rqst.get('delta_type'), rqst.get('message_search'))
322
482
def _calc_view_revisions(branch, start_rev_id, end_rev_id, direction,
335
495
generate_single_revision = (end_rev_id and start_rev_id == end_rev_id and
336
496
(not generate_merge_revisions or not _has_merges(branch, end_rev_id)))
337
497
if generate_single_revision:
338
if end_rev_id == br_rev_id:
340
return [(br_rev_id, br_revno, 0)]
342
revno = branch.revision_id_to_dotted_revno(end_rev_id)
343
if len(revno) > 1 and not allow_single_merge_revision:
344
# It's a merge revision and the log formatter is
345
# completely brain dead. This "feature" of allowing
346
# log formatters incapable of displaying dotted revnos
347
# ought to be deprecated IMNSHO. IGC 20091022
348
raise errors.BzrCommandError('Selected log formatter only'
349
' supports mainline revisions.')
350
revno_str = '.'.join(str(n) for n in revno)
351
return [(end_rev_id, revno_str, 0)]
498
return _generate_one_revision(branch, end_rev_id, br_rev_id, br_revno,
499
allow_single_merge_revision)
353
501
# If we only want to see linear revisions, we can iterate ...
354
502
if not generate_merge_revisions:
355
result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
356
# If a start limit was given and it's not obviously an
357
# ancestor of the end limit, check it before outputting anything
358
if direction == 'forward' or (start_rev_id
359
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
361
result = list(result)
362
except _StartNotLinearAncestor:
363
raise errors.BzrCommandError('Start revision not found in'
364
' left-hand history of end revision.')
365
if direction == 'forward':
366
result = reversed(list(result))
503
return _generate_flat_revisions(branch, start_rev_id, end_rev_id,
506
return _generate_all_revisions(branch, start_rev_id, end_rev_id,
507
direction, delayed_graph_generation)
510
def _generate_one_revision(branch, rev_id, br_rev_id, br_revno,
511
allow_single_merge_revision):
512
if rev_id == br_rev_id:
514
return [(br_rev_id, br_revno, 0)]
516
revno = branch.revision_id_to_dotted_revno(rev_id)
517
if len(revno) > 1 and not allow_single_merge_revision:
518
# It's a merge revision and the log formatter is
519
# completely brain dead. This "feature" of allowing
520
# log formatters incapable of displaying dotted revnos
521
# ought to be deprecated IMNSHO. IGC 20091022
522
raise errors.BzrCommandError('Selected log formatter only'
523
' supports mainline revisions.')
524
revno_str = '.'.join(str(n) for n in revno)
525
return [(rev_id, revno_str, 0)]
528
def _generate_flat_revisions(branch, start_rev_id, end_rev_id, direction):
529
result = _linear_view_revisions(branch, start_rev_id, end_rev_id)
530
# If a start limit was given and it's not obviously an
531
# ancestor of the end limit, check it before outputting anything
532
if direction == 'forward' or (start_rev_id
533
and not _is_obvious_ancestor(branch, start_rev_id, end_rev_id)):
535
result = list(result)
536
except _StartNotLinearAncestor:
537
raise errors.BzrCommandError('Start revision not found in'
538
' left-hand history of end revision.')
539
if direction == 'forward':
540
result = reversed(result)
544
def _generate_all_revisions(branch, start_rev_id, end_rev_id, direction,
545
delayed_graph_generation):
369
546
# On large trees, generating the merge graph can take 30-60 seconds
370
547
# so we delay doing it until a merge is detected, incrementally
371
548
# returning initial (non-merge) revisions while we can.
1615
1795
lf.log_revision(lr)
1618
def _get_fileid_to_log(revision, tree, b, fp):
1619
"""Find the file-id to log for a file path in a revision range.
1621
:param revision: the revision range as parsed on the command line
1622
:param tree: the working tree, if any
1623
:param b: the branch
1624
:param fp: file path
1798
def _get_info_for_log_files(revisionspec_list, file_list):
1799
"""Find file-ids and kinds given a list of files and a revision range.
1801
We search for files at the end of the range. If not found there,
1802
we try the start of the range.
1804
:param revisionspec_list: revision range as parsed on the command line
1805
:param file_list: the list of paths given on the command line;
1806
the first of these can be a branch location or a file path,
1807
the remainder must be file paths
1808
:return: (branch, info_list, start_rev_info, end_rev_info) where
1809
info_list is a list of (relative_path, file_id, kind) tuples where
1810
kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
1626
if revision is None:
1812
from builtins import _get_revision_range, safe_relpath_files
1813
tree, b, path = bzrdir.BzrDir.open_containing_tree_or_branch(file_list[0])
1814
# XXX: It's damn messy converting a list of paths to relative paths when
1815
# those paths might be deleted ones, they might be on a case-insensitive
1816
# filesystem and/or they might be in silly locations (like another branch).
1817
# For example, what should "log bzr://branch/dir/file1 file2" do? (Is
1818
# file2 implicitly in the same dir as file1 or should its directory be
1819
# taken from the current tree somehow?) For now, this solves the common
1820
# case of running log in a nested directory, assuming paths beyond the
1821
# first one haven't been deleted ...
1823
relpaths = [path] + safe_relpath_files(tree, file_list[1:])
1825
relpaths = [path] + file_list[1:]
1827
start_rev_info, end_rev_info = _get_revision_range(revisionspec_list, b,
1829
if start_rev_info is None and end_rev_info is None:
1627
1830
if tree is None:
1628
1831
tree = b.basis_tree()
1629
file_id = tree.path2id(fp)
1631
# go back to when time began
1633
rev1 = b.get_rev_id(1)
1634
except errors.NoSuchRevision:
1638
tree = b.repository.revision_tree(rev1)
1639
file_id = tree.path2id(fp)
1834
file_id = tree.path2id(fp)
1835
kind = _get_kind_for_file_id(tree, file_id)
1837
# go back to when time began
1840
rev1 = b.get_rev_id(1)
1841
except errors.NoSuchRevision:
1846
tree1 = b.repository.revision_tree(rev1)
1848
file_id = tree1.path2id(fp)
1849
kind = _get_kind_for_file_id(tree1, file_id)
1850
info_list.append((fp, file_id, kind))
1641
elif len(revision) == 1:
1852
elif start_rev_info == end_rev_info:
1642
1853
# One revision given - file must exist in it
1643
tree = revision[0].as_tree(b)
1644
file_id = tree.path2id(fp)
1854
tree = b.repository.revision_tree(end_rev_info.rev_id)
1856
file_id = tree.path2id(fp)
1857
kind = _get_kind_for_file_id(tree, file_id)
1858
info_list.append((fp, file_id, kind))
1646
elif len(revision) == 2:
1647
1861
# Revision range given. Get the file-id from the end tree.
1648
1862
# If that fails, try the start tree.
1649
rev_id = revision[1].as_revision_id(b)
1863
rev_id = end_rev_info.rev_id
1650
1864
if rev_id is None:
1651
1865
tree = b.basis_tree()
1653
tree = revision[1].as_tree(b)
1654
file_id = tree.path2id(fp)
1656
rev_id = revision[0].as_revision_id(b)
1658
rev1 = b.get_rev_id(1)
1659
tree = b.repository.revision_tree(rev1)
1661
tree = revision[0].as_tree(b)
1867
tree = b.repository.revision_tree(rev_id)
1662
1870
file_id = tree.path2id(fp)
1871
kind = _get_kind_for_file_id(tree, file_id)
1874
rev_id = start_rev_info.rev_id
1876
rev1 = b.get_rev_id(1)
1877
tree1 = b.repository.revision_tree(rev1)
1879
tree1 = b.repository.revision_tree(rev_id)
1880
file_id = tree1.path2id(fp)
1881
kind = _get_kind_for_file_id(tree1, file_id)
1882
info_list.append((fp, file_id, kind))
1883
return b, info_list, start_rev_info, end_rev_info
1886
def _get_kind_for_file_id(tree, file_id):
1887
"""Return the kind of a file-id or None if it doesn't exist."""
1888
if file_id is not None:
1889
return tree.kind(file_id)
1664
raise errors.BzrCommandError(
1665
'bzr log --revision takes one or two values.')
1669
1894
properties_handler_registry = registry.Registry()
added
removed
bzrlib/log.py
