1
# Copyright (C) 2005 Canonical Ltd
 
 
3
# This program is free software; you can redistribute it and/or modify
 
 
4
# it under the terms of the GNU General Public License as published by
 
 
5
# the Free Software Foundation; either version 2 of the License, or
 
 
6
# (at your option) any later version.
 
 
8
# This program is distributed in the hope that it will be useful,
 
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
 
11
# GNU General Public License for more details.
 
 
13
# You should have received a copy of the GNU General Public License
 
 
14
# along with this program; if not, write to the Free Software
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
19
"""Code to show logs of changes.
 
 
21
Various flavors of log can be produced:
 
 
23
* for one file, or the whole tree, and (not done yet) for
 
 
24
  files in a given directory
 
 
26
* in "verbose" mode with a description of what changed from one
 
 
29
* with file-ids and revision-ids shown
 
 
31
Logs are actually written out through an abstract LogFormatter
 
 
32
interface, which allows for different preferred formats.  Plugins can
 
 
35
Logs can be produced in either forward (oldest->newest) or reverse
 
 
36
(newest->oldest) order.
 
 
38
Logs can be filtered to show only revisions matching a particular
 
 
39
search string, or within a particular range of revisions.  The range
 
 
40
can be given as date/times, which are reduced to revisions before
 
 
43
In verbose mode we show a summary of what changed in each particular
 
 
44
revision.  Note that this is the delta for changes in that revision
 
 
45
relative to its mainline parent, not the delta relative to the last
 
 
46
logged revision.  So for example if you ask for a verbose log of
 
 
47
changes touching hello.c you will get a list of those revisions also
 
 
48
listing other things that were changed in the same revision, but not
 
 
49
all the changes since the previous revision that touched hello.c.
 
 
53
# TODO: option to show delta summaries for merged-in revisions
 
 
55
import bzrlib.errors as errors
 
 
56
from bzrlib.tree import EmptyTree
 
 
57
from bzrlib.delta import compare_trees
 
 
58
from bzrlib.trace import mutter
 
 
62
def find_touching_revisions(branch, file_id):
 
 
63
    """Yield a description of revisions which affect the file_id.
 
 
65
    Each returned element is (revno, revision_id, description)
 
 
67
    This is the list of revisions where the file is either added,
 
 
68
    modified, renamed or deleted.
 
 
70
    TODO: Perhaps some way to limit this to only particular revisions,
 
 
71
    or to traverse a non-mainline set of revisions?
 
 
76
    for revision_id in branch.revision_history():
 
 
77
        this_inv = branch.repository.get_revision_inventory(revision_id)
 
 
78
        if file_id in this_inv:
 
 
79
            this_ie = this_inv[file_id]
 
 
80
            this_path = this_inv.id2path(file_id)
 
 
82
            this_ie = this_path = None
 
 
84
        # now we know how it was last time, and how it is in this revision.
 
 
85
        # are those two states effectively the same or not?
 
 
87
        if not this_ie and not last_ie:
 
 
88
            # not present in either
 
 
90
        elif this_ie and not last_ie:
 
 
91
            yield revno, revision_id, "added " + this_path
 
 
92
        elif not this_ie and last_ie:
 
 
94
            yield revno, revision_id, "deleted " + last_path
 
 
95
        elif this_path != last_path:
 
 
96
            yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
 
 
97
        elif (this_ie.text_size != last_ie.text_size
 
 
98
              or this_ie.text_sha1 != last_ie.text_sha1):
 
 
99
            yield revno, revision_id, "modified " + this_path
 
 
102
        last_path = this_path
 
 
107
def _enumerate_history(branch):
 
 
110
    for rev_id in branch.revision_history():
 
 
111
        rh.append((revno, rev_id))
 
 
116
def _get_revision_delta(branch, revno):
 
 
117
    """Return the delta for a mainline revision.
 
 
119
    This is used to show summaries in verbose logs, and also for finding 
 
 
120
    revisions which touch a given file."""
 
 
121
    # XXX: What are we supposed to do when showing a summary for something 
 
 
122
    # other than a mainline revision.  The delta to it's first parent, or
 
 
123
    # (more useful) the delta to a nominated other revision.
 
 
124
    return branch.get_revision_delta(revno)
 
 
129
             specific_fileid=None,
 
 
135
    """Write out human-readable log of commits to this branch.
 
 
138
        LogFormatter object to show the output.
 
 
141
        If true, list only the commits affecting the specified
 
 
142
        file, rather than all commits.
 
 
145
        If true show added/changed/deleted/renamed files.
 
 
148
        'reverse' (default) is latest to earliest;
 
 
149
        'forward' is earliest to latest.
 
 
152
        If not None, only show revisions >= start_revision
 
 
155
        If not None, only show revisions <= end_revision
 
 
159
        _show_log(branch, lf, specific_fileid, verbose, direction,
 
 
160
                  start_revision, end_revision, search)
 
 
164
def _show_log(branch,
 
 
166
             specific_fileid=None,
 
 
172
    """Worker function for show_log - see show_log."""
 
 
173
    from bzrlib.osutils import format_date
 
 
174
    from bzrlib.errors import BzrCheckError
 
 
175
    from bzrlib.textui import show_status
 
 
177
    from warnings import warn
 
 
179
    if not isinstance(lf, LogFormatter):
 
 
180
        warn("not a LogFormatter instance: %r" % lf)
 
 
183
        mutter('get log for file_id %r', specific_fileid)
 
 
185
    if search is not None:
 
 
187
        searchRE = re.compile(search, re.IGNORECASE)
 
 
191
    which_revs = _enumerate_history(branch)
 
 
193
    if start_revision is None:
 
 
196
        branch.check_real_revno(start_revision)
 
 
198
    if end_revision is None:
 
 
199
        end_revision = len(which_revs)
 
 
201
        branch.check_real_revno(end_revision)
 
 
203
    # list indexes are 0-based; revisions are 1-based
 
 
204
    cut_revs = which_revs[(start_revision-1):(end_revision)]
 
 
206
    if direction == 'reverse':
 
 
208
    elif direction == 'forward':
 
 
211
        raise ValueError('invalid direction %r' % direction)
 
 
213
    revision_history = branch.revision_history()
 
 
214
    for revno, rev_id in cut_revs:
 
 
215
        if verbose or specific_fileid:
 
 
216
            delta = _get_revision_delta(branch, revno)
 
 
219
            if not delta.touches_file_id(specific_fileid):
 
 
223
            # although we calculated it, throw it away without display
 
 
226
        rev = branch.repository.get_revision(rev_id)
 
 
229
            if not searchRE.search(rev.message):
 
 
232
        lf.show(revno, rev, delta)
 
 
233
        if hasattr(lf, 'show_merge'):
 
 
237
                # revno is 1 based, so -2 to get back 1 less.
 
 
238
                repository = branch.repository
 
 
239
                excludes = repository.get_ancestry(revision_history[revno - 2])
 
 
240
                excludes = set(excludes)
 
 
241
            pending = list(rev.parent_ids)
 
 
243
                rev_id = pending.pop()
 
 
244
                if rev_id in excludes:
 
 
246
                # prevent showing merged revs twice if they multi-path.
 
 
249
                    rev = branch.repository.get_revision(rev_id)
 
 
250
                except errors.NoSuchRevision:
 
 
252
                pending.extend(rev.parent_ids)
 
 
256
def deltas_for_log_dummy(branch, which_revs):
 
 
257
    """Return all the revisions without intermediate deltas.
 
 
259
    Useful for log commands that won't need the delta information.
 
 
262
    for revno, revision_id in which_revs:
 
 
263
        yield revno, branch.get_revision(revision_id), None
 
 
266
def deltas_for_log_reverse(branch, which_revs):
 
 
267
    """Compute deltas for display in latest-to-earliest order.
 
 
273
        Sequence of (revno, revision_id) for the subset of history to examine
 
 
276
        Sequence of (revno, rev, delta)
 
 
278
    The delta is from the given revision to the next one in the
 
 
279
    sequence, which makes sense if the log is being displayed from
 
 
282
    last_revno = last_revision_id = last_tree = None
 
 
283
    for revno, revision_id in which_revs:
 
 
284
        this_tree = branch.revision_tree(revision_id)
 
 
285
        this_revision = branch.get_revision(revision_id)
 
 
288
            yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
 
290
        this_tree = EmptyTree(branch.get_root_id())
 
 
293
        last_revision = this_revision
 
 
294
        last_tree = this_tree
 
 
298
            this_tree = EmptyTree(branch.get_root_id())
 
 
300
            this_revno = last_revno - 1
 
 
301
            this_revision_id = branch.revision_history()[this_revno]
 
 
302
            this_tree = branch.revision_tree(this_revision_id)
 
 
303
        yield last_revno, last_revision, compare_trees(this_tree, last_tree, False)
 
 
306
def deltas_for_log_forward(branch, which_revs):
 
 
307
    """Compute deltas for display in forward log.
 
 
309
    Given a sequence of (revno, revision_id) pairs, return
 
 
312
    The delta is from the given revision to the next one in the
 
 
313
    sequence, which makes sense if the log is being displayed from
 
 
316
    last_revno = last_revision_id = last_tree = None
 
 
317
    prev_tree = EmptyTree(branch.get_root_id())
 
 
319
    for revno, revision_id in which_revs:
 
 
320
        this_tree = branch.revision_tree(revision_id)
 
 
321
        this_revision = branch.get_revision(revision_id)
 
 
325
                last_tree = EmptyTree(branch.get_root_id())
 
 
327
                last_revno = revno - 1
 
 
328
                last_revision_id = branch.revision_history()[last_revno]
 
 
329
                last_tree = branch.revision_tree(last_revision_id)
 
 
331
        yield revno, this_revision, compare_trees(last_tree, this_tree, False)
 
 
334
        last_revision = this_revision
 
 
335
        last_tree = this_tree
 
 
338
class LogFormatter(object):
 
 
339
    """Abstract class to display log messages."""
 
 
340
    def __init__(self, to_file, show_ids=False, show_timezone='original'):
 
 
341
        self.to_file = to_file
 
 
342
        self.show_ids = show_ids
 
 
343
        self.show_timezone = show_timezone
 
 
346
    def show(self, revno, rev, delta):
 
 
347
        raise NotImplementedError('not implemented in abstract base')
 
 
349
    def short_committer(self, rev):
 
 
350
        return re.sub('<.*@.*>', '', rev.committer).strip(' ')
 
 
353
class LongLogFormatter(LogFormatter):
 
 
354
    def show(self, revno, rev, delta):
 
 
355
        return self._show_helper(revno=revno, rev=rev, delta=delta)
 
 
357
    def show_merge(self, rev):
 
 
358
        return self._show_helper(rev=rev, indent='    ', merged=True, delta=None)
 
 
360
    def _show_helper(self, rev=None, revno=None, indent='', merged=False, delta=None):
 
 
361
        """Show a revision, either merged or not."""
 
 
362
        from bzrlib.osutils import format_date
 
 
363
        to_file = self.to_file
 
 
364
        print >>to_file,  indent+'-' * 60
 
 
365
        if revno is not None:
 
 
366
            print >>to_file,  'revno:', revno
 
 
368
            print >>to_file,  indent+'merged:', rev.revision_id
 
 
370
            print >>to_file,  indent+'revision-id:', rev.revision_id
 
 
372
            for parent_id in rev.parent_ids:
 
 
373
                print >>to_file, indent+'parent:', parent_id
 
 
374
        print >>to_file,  indent+'committer:', rev.committer
 
 
376
            print >>to_file, indent+'branch nick: %s' % \
 
 
377
                rev.properties['branch-nick']
 
 
380
        date_str = format_date(rev.timestamp,
 
 
383
        print >>to_file,  indent+'timestamp: %s' % date_str
 
 
385
        print >>to_file,  indent+'message:'
 
 
387
            print >>to_file,  indent+'  (no message)'
 
 
389
            message = rev.message.rstrip('\r\n')
 
 
390
            for l in message.split('\n'):
 
 
391
                print >>to_file,  indent+'  ' + l
 
 
393
            delta.show(to_file, self.show_ids)
 
 
396
class ShortLogFormatter(LogFormatter):
 
 
397
    def show(self, revno, rev, delta):
 
 
398
        from bzrlib.osutils import format_date
 
 
400
        to_file = self.to_file
 
 
401
        date_str = format_date(rev.timestamp, rev.timezone or 0,
 
 
403
        print >>to_file, "%5d %s\t%s" % (revno, self.short_committer(rev),
 
 
404
                format_date(rev.timestamp, rev.timezone or 0,
 
 
405
                            self.show_timezone, date_fmt="%Y-%m-%d",
 
 
408
            print >>to_file,  '      revision-id:', rev.revision_id
 
 
410
            print >>to_file,  '      (no message)'
 
 
412
            message = rev.message.rstrip('\r\n')
 
 
413
            for l in message.split('\n'):
 
 
414
                print >>to_file,  '      ' + l
 
 
416
        # TODO: Why not show the modified files in a shorter form as
 
 
417
        # well? rewrap them single lines of appropriate length
 
 
419
            delta.show(to_file, self.show_ids)
 
 
422
class LineLogFormatter(LogFormatter):
 
 
423
    def truncate(self, str, max_len):
 
 
424
        if len(str) <= max_len:
 
 
426
        return str[:max_len-3]+'...'
 
 
428
    def date_string(self, rev):
 
 
429
        from bzrlib.osutils import format_date
 
 
430
        return format_date(rev.timestamp, rev.timezone or 0, 
 
 
431
                           self.show_timezone, date_fmt="%Y-%m-%d",
 
 
434
    def message(self, rev):
 
 
436
            return '(no message)'
 
 
440
    def show(self, revno, rev, delta):
 
 
441
        print >> self.to_file, self.log_string(rev, 79) 
 
 
443
    def log_string(self, rev, max_chars):
 
 
444
        out = [self.truncate(self.short_committer(rev), 20)]
 
 
445
        out.append(self.date_string(rev))
 
 
446
        out.append(self.message(rev).replace('\n', ' '))
 
 
447
        return self.truncate(" ".join(out).rstrip('\n'), max_chars)
 
 
449
def line_log(rev, max_chars):
 
 
450
    lf = LineLogFormatter(None)
 
 
451
    return lf.log_string(rev, max_chars)
 
 
454
              'long': LongLogFormatter,
 
 
455
              'short': ShortLogFormatter,
 
 
456
              'line': LineLogFormatter,
 
 
459
def register_formatter(name, formatter):
 
 
460
    FORMATTERS[name] = formatter
 
 
462
def log_formatter(name, *args, **kwargs):
 
 
463
    """Construct a formatter from arguments.
 
 
465
    name -- Name of the formatter to construct; currently 'long', 'short' and
 
 
466
        'line' are supported.
 
 
468
    from bzrlib.errors import BzrCommandError
 
 
470
        return FORMATTERS[name](*args, **kwargs)
 
 
472
        raise BzrCommandError("unknown log formatter: %r" % name)
 
 
474
def show_one_log(revno, rev, delta, verbose, to_file, show_timezone):
 
 
475
    # deprecated; for compatability
 
 
476
    lf = LongLogFormatter(to_file=to_file, show_timezone=show_timezone)
 
 
477
    lf.show(revno, rev, delta)
 
 
479
def show_changed_revisions(branch, old_rh, new_rh, to_file=None, log_format='long'):
 
 
480
    """Show the change in revision history comparing the old revision history to the new one.
 
 
482
    :param branch: The branch where the revisions exist
 
 
483
    :param old_rh: The old revision history
 
 
484
    :param new_rh: The new revision history
 
 
485
    :param to_file: A file to write the results to. If None, stdout will be used
 
 
491
        to_file = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
 
 
492
    lf = log_formatter(log_format,
 
 
495
                       show_timezone='original')
 
 
497
    # This is the first index which is different between
 
 
500
    for i in xrange(max(len(new_rh),
 
 
504
            or new_rh[i] != old_rh[i]):
 
 
509
        to_file.write('Nothing seems to have changed\n')
 
 
511
    ## TODO: It might be nice to do something like show_log
 
 
512
    ##       and show the merged entries. But since this is the
 
 
513
    ##       removed revisions, it shouldn't be as important
 
 
514
    if base_idx < len(old_rh):
 
 
515
        to_file.write('*'*60)
 
 
516
        to_file.write('\nRemoved Revisions:\n')
 
 
517
        for i in range(base_idx, len(old_rh)):
 
 
518
            rev = branch.repository.get_revision(old_rh[i])
 
 
519
            lf.show(i+1, rev, None)
 
 
520
        to_file.write('*'*60)
 
 
521
        to_file.write('\n\n')
 
 
522
    if base_idx < len(new_rh):
 
 
523
        to_file.write('Added Revisions:\n')
 
 
529
                 start_revision=base_idx+1,
 
 
530
                 end_revision=len(new_rh),