← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/annotate.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-16 16:58:03 UTC
  • mfrom: (3224.3.1 news-typo)
  • Revision ID: pqm@pqm.ubuntu.com-20080316165803-tisoc9mpob9z544o
(Matt Nordhoff) Trivial NEWS typo fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/annotate.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""File annotate based on weave storage"""
18
18
 
19
19
# TODO: Choice of more or less verbose formats:
20
 
#
 
20
# 
21
21
# interposed: show more details between blocks of modified lines
22
22
 
23
23
# TODO: Show which revision caused a line to merge into the parent
24
24
 
25
25
# TODO: perhaps abbreviate timescales depending on how recent they are
26
 
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.
 
26
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.  
27
27
 
28
28
import sys
29
29
import time
30
30
 
31
 
from bzrlib.lazy_import import lazy_import
32
 
lazy_import(globals(), """
33
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
34
34
    patiencediff,
35
35
    tsort,
36
36
    )
37
 
""")
38
 
from bzrlib import (
39
 
    errors,
40
 
    osutils,
41
 
    )
42
37
from bzrlib.config import extract_email_address
43
 
from bzrlib.repository import _strip_NULL_ghosts
44
 
from bzrlib.revision import (
45
 
    CURRENT_REVISION,
46
 
    Revision,
47
 
    )
48
 
from bzrlib.symbol_versioning import (
49
 
    deprecated_function,
50
 
    deprecated_in,
51
 
    )
52
 
 
53
 
 
54
 
@deprecated_function(deprecated_in((2, 4, 0)))
 
38
 
 
39
 
55
40
def annotate_file(branch, rev_id, file_id, verbose=False, full=False,
56
41
                  to_file=None, show_ids=False):
57
42
    """Annotate file_id at revision rev_id in branch.
68
53
        used.
69
54
    :param show_ids: Show revision ids in the annotation output.
70
55
    """
71
 
    tree = branch.repository.revision_tree(rev_id)
72
 
    annotate_file_tree(tree, file_id, to_file, verbose=verbose,
73
 
        full=full, show_ids=show_ids, branch=branch)
74
 
 
75
 
 
76
 
def annotate_file_tree(tree, file_id, to_file, verbose=False, full=False,
77
 
    show_ids=False, branch=None):
78
 
    """Annotate file_id in a tree.
79
 
 
80
 
    The tree should already be read_locked() when annotate_file_tree is called.
81
 
 
82
 
    :param tree: The tree to look for revision numbers and history from.
83
 
    :param file_id: The file_id to annotate.
84
 
    :param to_file: The file to output the annotation to.
85
 
    :param verbose: Show all details rather than truncating to ensure
86
 
        reasonable text width.
87
 
    :param full: XXXX Not sure what this does.
88
 
    :param show_ids: Show revision ids in the annotation output.
89
 
    :param branch: Branch to use for revision revno lookups
90
 
    """
91
 
    if branch is None:
92
 
        branch = tree.branch
93
56
    if to_file is None:
94
57
        to_file = sys.stdout
95
58
 
96
59
    # Handle the show_ids case
97
 
    annotations = list(tree.annotate_iter(file_id))
 
60
    last_rev_id = None
98
61
    if show_ids:
99
 
        return _show_id_annotations(annotations, to_file, full)
100
 
 
101
 
    if not getattr(tree, "get_revision_id", False):
102
 
        # Create a virtual revision to represent the current tree state.
103
 
        # Should get some more pending commit attributes, like pending tags,
104
 
        # bugfixes etc.
105
 
        current_rev = Revision(CURRENT_REVISION)
106
 
        current_rev.parent_ids = tree.get_parent_ids()
107
 
        try:
108
 
            current_rev.committer = branch.get_config().username()
109
 
        except errors.NoWhoami:
110
 
            current_rev.committer = 'local user'
111
 
        current_rev.message = "?"
112
 
        current_rev.timestamp = round(time.time(), 3)
113
 
        current_rev.timezone = osutils.local_time_offset()
114
 
    else:
115
 
        current_rev = None
116
 
    annotation = list(_expand_annotations(annotations, branch,
117
 
        current_rev))
118
 
    _print_annotations(annotation, verbose, to_file, full)
119
 
 
120
 
 
121
 
def _print_annotations(annotation, verbose, to_file, full):
122
 
    """Print annotations to to_file.
123
 
 
124
 
    :param to_file: The file to output the annotation to.
125
 
    :param verbose: Show all details rather than truncating to ensure
126
 
        reasonable text width.
127
 
    :param full: XXXX Not sure what this does.
128
 
    """
 
62
        annotations = _annotations(branch.repository, file_id, rev_id)
 
63
        max_origin_len = max(len(origin) for origin, text in annotations)
 
64
        for origin, text in annotations:
 
65
            if full or last_rev_id != origin:
 
66
                this = origin
 
67
            else:
 
68
                this = ''
 
69
            to_file.write('%*s | %s' % (max_origin_len, this, text))
 
70
            last_rev_id = origin
 
71
        return
 
72
 
 
73
    # Calculate the lengths of the various columns
 
74
    annotation = list(_annotate_file(branch, rev_id, file_id))
129
75
    if len(annotation) == 0:
130
76
        max_origin_len = max_revno_len = max_revid_len = 0
131
77
    else:
164
110
        prevanno = anno
165
111
 
166
112
 
167
 
def _show_id_annotations(annotations, to_file, full):
168
 
    if not annotations:
169
 
        return
170
 
    last_rev_id = None
171
 
    max_origin_len = max(len(origin) for origin, text in annotations)
172
 
    for origin, text in annotations:
173
 
        if full or last_rev_id != origin:
174
 
            this = origin
175
 
        else:
176
 
            this = ''
177
 
        to_file.write('%*s | %s' % (max_origin_len, this, text))
178
 
        last_rev_id = origin
179
 
    return
180
 
 
181
 
 
182
 
def _expand_annotations(annotations, branch, current_rev=None):
183
 
    """Expand a file's annotations into command line UI ready tuples.
184
 
 
185
 
    Each tuple includes detailed information, such as the author name, and date
186
 
    string for the commit, rather than just the revision id.
187
 
 
188
 
    :param annotations: The annotations to expand.
189
 
    :param revision_id_to_revno: A map from id to revision numbers.
190
 
    :param branch: A locked branch to query for revision details.
 
113
def _annotations(repo, file_id, rev_id):
 
114
    """Return the list of (origin,text) for a revision of a file in a repository."""
 
115
    w = repo.weave_store.get_weave(file_id, repo.get_transaction())
 
116
    return list(w.annotate_iter(rev_id))
 
117
 
 
118
 
 
119
def _annotate_file(branch, rev_id, file_id):
 
120
    """Yield the origins for each line of a file.
 
121
 
 
122
    This includes detailed information, such as the author name, and
 
123
    date string for the commit, rather than just the revision id.
191
124
    """
192
 
    repository = branch.repository
193
 
    if current_rev is not None:
194
 
        # This can probably become a function on MutableTree, get_revno_map
195
 
        # there, or something.
196
 
        last_revision = current_rev.revision_id
197
 
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
198
 
        # XXX: The main difficulty is that we need to inject a single new node
199
 
        #      (current_rev) into the graph before it gets numbered, etc.
200
 
        #      Once KnownGraph gets an 'add_node()' function, we can use
201
 
        #      VF.get_known_graph_ancestry().
202
 
        graph = repository.get_graph()
203
 
        revision_graph = dict(((key, value) for key, value in
204
 
            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
205
 
        revision_graph = _strip_NULL_ghosts(revision_graph)
206
 
        revision_graph[last_revision] = current_rev.parent_ids
207
 
        merge_sorted_revisions = tsort.merge_sort(
208
 
            revision_graph,
209
 
            last_revision,
210
 
            None,
211
 
            generate_revno=True)
212
 
        revision_id_to_revno = dict((rev_id, revno)
213
 
            for seq_num, rev_id, depth, revno, end_of_merge in
214
 
                merge_sorted_revisions)
215
 
    else:
216
 
        revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
125
    revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
126
    annotations = _annotations(branch.repository, file_id, rev_id)
217
127
    last_origin = None
218
128
    revision_ids = set(o for o, t in annotations)
219
 
    revisions = {}
220
 
    if CURRENT_REVISION in revision_ids:
221
 
        revision_id_to_revno[CURRENT_REVISION] = (
222
 
            "%d?" % (branch.revno() + 1),)
223
 
        revisions[CURRENT_REVISION] = current_rev
224
 
    revision_ids = [o for o in revision_ids if
225
 
                    repository.has_revision(o)]
226
 
    revisions.update((r.revision_id, r) for r in
227
 
                     repository.get_revisions(revision_ids))
 
129
    revision_ids = [o for o in revision_ids if 
 
130
                    branch.repository.has_revision(o)]
 
131
    revisions = dict((r.revision_id, r) for r in 
 
132
                     branch.repository.get_revisions(revision_ids))
228
133
    for origin, text in annotations:
229
134
        text = text.rstrip('\r\n')
230
135
        if origin == last_origin:
242
147
                                     time.gmtime(rev.timestamp + tz))
243
148
            # a lazy way to get something like the email address
244
149
            # TODO: Get real email address
245
 
            author = rev.get_apparent_authors()[0]
 
150
            author = rev.get_apparent_author()
246
151
            try:
247
152
                author = extract_email_address(author)
248
153
            except errors.NoEmailInUsername:
254
159
               _left_matching_blocks=None,
255
160
               heads_provider=None):
256
161
    """Create a new annotated version from new lines and parent annotations.
257
 
 
 
162
    
258
163
    :param parents_lines: List of annotated lines for all parents
259
164
    :param new_lines: The un-annotated new lines
260
165
    :param new_revision_id: The revision-id to associate with new lines
263
168
        between the text and its left-hand-parent.  The format is
264
169
        the SequenceMatcher.get_matching_blocks format
265
170
        (start_left, start_right, length_of_match).
266
 
    :param heads_provider: An object which provides a .heads() call to resolve
 
171
    :param heads_provider: An object which provids a .heads() call to resolve
267
172
        if any revision ids are children of others.
268
173
        If None, then any ancestry disputes will be resolved with
269
174
        new_revision_id
319
224
 
320
225
 
321
226
def _get_matching_blocks(old, new):
322
 
    matcher = patiencediff.PatienceSequenceMatcher(None, old, new)
 
227
    matcher = patiencediff.PatienceSequenceMatcher(None,
 
228
        old, new)
323
229
    return matcher.get_matching_blocks()
324
230
 
325
231
 
326
 
_break_annotation_tie = None
327
 
 
328
 
def _old_break_annotation_tie(annotated_lines):
329
 
    """Chose an attribution between several possible ones.
330
 
 
331
 
    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where
332
 
        the lines are identical but the revids different while no parent
333
 
        relation exist between them
334
 
 
335
 
     :return : The "winning" line. This must be one with a revid that
336
 
         guarantees that further criss-cross merges will converge. Failing to
337
 
         do so have performance implications.
338
 
    """
339
 
    # sort lexicographically so that we always get a stable result.
340
 
 
341
 
    # TODO: while 'sort' is the easiest (and nearly the only possible solution)
342
 
    # with the current implementation, chosing the oldest revision is known to
343
 
    # provide better results (as in matching user expectations). The most
344
 
    # common use case being manual cherry-pick from an already existing
345
 
    # revision.
346
 
    return sorted(annotated_lines)[0]
347
 
 
348
 
 
349
232
def _find_matching_unannotated_lines(output_lines, plain_child_lines,
350
233
                                     child_lines, start_child, end_child,
351
234
                                     right_lines, start_right, end_right,
356
239
    :param plain_child_lines: The unannotated new lines for the child text
357
240
    :param child_lines: Lines for the child text which have been annotated
358
241
        for the left parent
359
 
 
360
 
    :param start_child: Position in plain_child_lines and child_lines to start
361
 
        the match searching
362
 
    :param end_child: Last position in plain_child_lines and child_lines to
363
 
        search for a match
 
242
    :param start_child: Position in plain_child_lines and child_lines to start the
 
243
        match searching
 
244
    :param end_child: Last position in plain_child_lines and child_lines to search
 
245
        for a match
364
246
    :param right_lines: The annotated lines for the whole text for the right
365
247
        parent
366
248
    :param start_right: Position in right_lines to start the match
402
284
                    if len(heads) == 1:
403
285
                        output_append((iter(heads).next(), left[1]))
404
286
                    else:
405
 
                        # Both claim different origins, get a stable result.
406
 
                        # If the result is not stable, there is a risk a
407
 
                        # performance degradation as criss-cross merges will
408
 
                        # flip-flop the attribution.
409
 
                        if _break_annotation_tie is None:
410
 
                            output_append(
411
 
                                _old_break_annotation_tie([left, right]))
412
 
                        else:
413
 
                            output_append(_break_annotation_tie([left, right]))
 
287
                        # Both claim different origins
 
288
                        output_append((revision_id, left[1]))
 
289
                        # We know that revision_id is the head for
 
290
                        # left and right, so cache it
 
291
                        heads_provider.cache(
 
292
                            (revision_id, left[0]),
 
293
                            (revision_id,))
 
294
                        heads_provider.cache(
 
295
                            (revision_id, right[0]),
 
296
                            (revision_id,))
414
297
        last_child_idx = child_idx + match_len
415
298
 
416
299
 
428
311
    :param heads_provider: When parents disagree on the lineage of a line, we
429
312
        need to check if one side supersedes the other.
430
313
    """
431
 
    if len(new_lines) != len(annotated_lines):
432
 
        raise AssertionError("mismatched new_lines and annotated_lines")
 
314
    assert len(new_lines) == len(annotated_lines)
433
315
    # First compare the newly annotated lines with the right annotated lines.
434
316
    # Lines which were not changed in left or right should match. This tends to
435
317
    # be the bulk of the lines, and they will need no further processing.
440
322
    matching_left_and_right = _get_matching_blocks(right_parent_lines,
441
323
                                                   annotated_lines)
442
324
    for right_idx, left_idx, match_len in matching_left_and_right:
443
 
        # annotated lines from last_left_idx to left_idx did not match the
444
 
        # lines from last_right_idx to right_idx, the raw lines should be
445
 
        # compared to determine what annotations need to be updated
 
325
        # annotated lines from last_left_idx to left_idx did not match the lines from
 
326
        # last_right_idx
 
327
        # to right_idx, the raw lines should be compared to determine what annotations
 
328
        # need to be updated
446
329
        if last_right_idx == right_idx or last_left_idx == left_idx:
447
330
            # One of the sides is empty, so this is a pure insertion
448
331
            lines_extend(annotated_lines[last_left_idx:left_idx])
458
341
        last_right_idx = right_idx + match_len
459
342
        last_left_idx = left_idx + match_len
460
343
        # If left and right agree on a range, just push that into the output
 
344
        assert len(lines) == left_idx
461
345
        lines_extend(annotated_lines[left_idx:left_idx + match_len])
462
346
    return lines
463
 
 
464
 
 
465
 
try:
466
 
    from bzrlib._annotator_pyx import Annotator
467
 
except ImportError, e:
468
 
    osutils.failed_to_load_extension(e)
469
 
    from bzrlib._annotator_py import Annotator