/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/annotate.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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, 2008, 2009 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
16
16
 
17
17
"""File annotate based on weave storage"""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
# TODO: Choice of more or less verbose formats:
22
20
#
23
21
# interposed: show more details between blocks of modified lines
30
28
import sys
31
29
import time
32
30
 
33
 
from .lazy_import import lazy_import
34
 
lazy_import(globals(), """
35
 
from breezy import (
 
31
from bzrlib import (
 
32
    errors,
 
33
    osutils,
36
34
    patiencediff,
37
35
    tsort,
38
36
    )
39
 
""")
40
 
from . import (
41
 
    errors,
42
 
    osutils,
43
 
    )
44
 
from .config import (
45
 
    NoEmailInUsername,
46
 
    NoWhoami,
47
 
    extract_email_address,
48
 
    )
49
 
from .repository import _strip_NULL_ghosts
50
 
from .revision import (
51
 
    CURRENT_REVISION,
52
 
    Revision,
53
 
    )
54
 
 
55
 
 
56
 
def annotate_file_tree(tree, path, to_file, verbose=False, full=False,
57
 
    show_ids=False, branch=None, file_id=None):
 
37
from bzrlib.config import extract_email_address
 
38
from bzrlib.repository import _strip_NULL_ghosts
 
39
from bzrlib.revision import CURRENT_REVISION, Revision
 
40
 
 
41
 
 
42
def annotate_file(branch, rev_id, file_id, verbose=False, full=False,
 
43
                  to_file=None, show_ids=False):
 
44
    """Annotate file_id at revision rev_id in branch.
 
45
 
 
46
    The branch should already be read_locked() when annotate_file is called.
 
47
 
 
48
    :param branch: The branch to look for revision numbers and history from.
 
49
    :param rev_id: The revision id to annotate.
 
50
    :param file_id: The file_id to annotate.
 
51
    :param verbose: Show all details rather than truncating to ensure
 
52
        reasonable text width.
 
53
    :param full: XXXX Not sure what this does.
 
54
    :param to_file: The file to output the annotation to; if None stdout is
 
55
        used.
 
56
    :param show_ids: Show revision ids in the annotation output.
 
57
    """
 
58
    if to_file is None:
 
59
        to_file = sys.stdout
 
60
 
 
61
    # Handle the show_ids case
 
62
    annotations = _annotations(branch.repository, file_id, rev_id)
 
63
    if show_ids:
 
64
        return _show_id_annotations(annotations, to_file, full)
 
65
 
 
66
    # Calculate the lengths of the various columns
 
67
    annotation = list(_expand_annotations(annotations, branch))
 
68
    _print_annotations(annotation, verbose, to_file, full)
 
69
 
 
70
 
 
71
def annotate_file_tree(tree, file_id, to_file, verbose=False, full=False,
 
72
    show_ids=False):
58
73
    """Annotate file_id in a tree.
59
74
 
60
75
    The tree should already be read_locked() when annotate_file_tree is called.
61
76
 
62
77
    :param tree: The tree to look for revision numbers and history from.
63
 
    :param path: The path to annotate
 
78
    :param file_id: The file_id to annotate.
64
79
    :param to_file: The file to output the annotation to.
65
80
    :param verbose: Show all details rather than truncating to ensure
66
81
        reasonable text width.
67
82
    :param full: XXXX Not sure what this does.
68
83
    :param show_ids: Show revision ids in the annotation output.
69
 
    :param file_id: The file_id to annotate (must match file path)
70
 
    :param branch: Branch to use for revision revno lookups
71
84
    """
72
 
    if branch is None:
73
 
        branch = tree.branch
74
 
    if to_file is None:
75
 
        to_file = sys.stdout
 
85
    rev_id = tree.last_revision()
 
86
    branch = tree.branch
76
87
 
77
 
    encoding = osutils.get_terminal_encoding()
78
88
    # Handle the show_ids case
79
 
    annotations = list(tree.annotate_iter(path, file_id))
 
89
    annotations = list(tree.annotate_iter(file_id))
80
90
    if show_ids:
81
 
        return _show_id_annotations(annotations, to_file, full, encoding)
 
91
        return _show_id_annotations(annotations, to_file, full)
82
92
 
83
 
    if not getattr(tree, "get_revision_id", False):
84
 
        # Create a virtual revision to represent the current tree state.
85
 
        # Should get some more pending commit attributes, like pending tags,
86
 
        # bugfixes etc.
87
 
        current_rev = Revision(CURRENT_REVISION)
88
 
        current_rev.parent_ids = tree.get_parent_ids()
89
 
        try:
90
 
            current_rev.committer = branch.get_config_stack().get('email')
91
 
        except NoWhoami:
92
 
            current_rev.committer = 'local user'
93
 
        current_rev.message = "?"
94
 
        current_rev.timestamp = round(time.time(), 3)
95
 
        current_rev.timezone = osutils.local_time_offset()
96
 
    else:
97
 
        current_rev = None
98
 
    annotation = list(_expand_annotations(annotations, branch,
 
93
    # Create a virtual revision to represent the current tree state.
 
94
    # Should get some more pending commit attributes, like pending tags,
 
95
    # bugfixes etc.
 
96
    current_rev = Revision(CURRENT_REVISION)
 
97
    current_rev.parent_ids = tree.get_parent_ids()
 
98
    current_rev.committer = tree.branch.get_config().username()
 
99
    current_rev.message = "?"
 
100
    current_rev.timestamp = round(time.time(), 3)
 
101
    current_rev.timezone = osutils.local_time_offset()
 
102
    annotation = list(_expand_annotations(annotations, tree.branch,
99
103
        current_rev))
100
 
    _print_annotations(annotation, verbose, to_file, full, encoding)
101
 
 
102
 
 
103
 
def _print_annotations(annotation, verbose, to_file, full, encoding):
 
104
    _print_annotations(annotation, verbose, to_file, full)
 
105
 
 
106
 
 
107
def _print_annotations(annotation, verbose, to_file, full):
104
108
    """Print annotations to to_file.
105
109
 
106
110
    :param to_file: The file to output the annotation to.
120
124
 
121
125
    # Output the annotations
122
126
    prevanno = ''
 
127
    encoding = getattr(to_file, 'encoding', None) or \
 
128
            osutils.get_terminal_encoding()
123
129
    for (revno_str, author, date_str, line_rev_id, text) in annotation:
124
130
        if verbose:
125
131
            anno = '%-*s %-*s %8s ' % (max_revno_len, revno_str,
130
136
            anno = "%-*s %-7s " % (max_revno_len, revno_str, author[:7])
131
137
        if anno.lstrip() == "" and full:
132
138
            anno = prevanno
133
 
        # GZ 2017-05-21: Writing both unicode annotation and bytes from file
134
 
        # which the given to_file must cope with.
135
 
        to_file.write(anno)
136
 
        to_file.write('| %s\n' % (text.decode(encoding),))
 
139
        try:
 
140
            to_file.write(anno)
 
141
        except UnicodeEncodeError:
 
142
            # cmd_annotate should be passing in an 'exact' object, which means
 
143
            # we have a direct handle to sys.stdout or equivalent. It may not
 
144
            # be able to handle the exact Unicode characters, but 'annotate' is
 
145
            # a user function (non-scripting), so shouldn't die because of
 
146
            # unrepresentable annotation characters. So encode using 'replace',
 
147
            # and write them again.
 
148
            to_file.write(anno.encode(encoding, 'replace'))
 
149
        to_file.write('| %s\n' % (text,))
137
150
        prevanno = anno
138
151
 
139
152
 
140
 
def _show_id_annotations(annotations, to_file, full, encoding):
 
153
def _show_id_annotations(annotations, to_file, full):
141
154
    if not annotations:
142
155
        return
143
156
    last_rev_id = None
146
159
        if full or last_rev_id != origin:
147
160
            this = origin
148
161
        else:
149
 
            this = b''
150
 
        to_file.write('%*s | %s' % (max_origin_len, this.decode('utf-8'),
151
 
            text.decode(encoding)))
 
162
            this = ''
 
163
        to_file.write('%*s | %s' % (max_origin_len, this, text))
152
164
        last_rev_id = origin
153
165
    return
154
166
 
155
167
 
 
168
def _annotations(repo, file_id, rev_id):
 
169
    """Return the list of (origin_revision_id, line_text) for a revision of a file in a repository."""
 
170
    annotations = repo.texts.annotate((file_id, rev_id))
 
171
    #
 
172
    return [(key[-1], line) for (key, line) in annotations]
 
173
 
 
174
 
156
175
def _expand_annotations(annotations, branch, current_rev=None):
157
176
    """Expand a file's annotations into command line UI ready tuples.
158
177
 
164
183
    :param branch: A locked branch to query for revision details.
165
184
    """
166
185
    repository = branch.repository
167
 
    revision_ids = set(o for o, t in annotations)
168
186
    if current_rev is not None:
169
 
        # This can probably become a function on MutableTree, get_revno_map
170
 
        # there, or something.
 
187
        # This can probably become a function on MutableTree, get_revno_map there,
 
188
        # or something.
171
189
        last_revision = current_rev.revision_id
172
190
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
173
191
        # XXX: The main difficulty is that we need to inject a single new node
188
206
            for seq_num, rev_id, depth, revno, end_of_merge in
189
207
                merge_sorted_revisions)
190
208
    else:
191
 
        # TODO(jelmer): Only look up the revision ids that we need (i.e. those
192
 
        # in revision_ids). Possibly add a HPSS call that can look those up
193
 
        # in bulk over HPSS.
194
209
        revision_id_to_revno = branch.get_revision_id_to_revno_map()
195
210
    last_origin = None
 
211
    revision_ids = set(o for o, t in annotations)
196
212
    revisions = {}
197
213
    if CURRENT_REVISION in revision_ids:
198
214
        revision_id_to_revno[CURRENT_REVISION] = (
199
215
            "%d?" % (branch.revno() + 1),)
200
216
        revisions[CURRENT_REVISION] = current_rev
201
 
    revisions.update(
202
 
            entry for entry in
203
 
            repository.iter_revisions(revision_ids)
204
 
            if entry[1] is not None)
 
217
    revision_ids = [o for o in revision_ids if
 
218
                    repository.has_revision(o)]
 
219
    revisions.update((r.revision_id, r) for r in
 
220
                     repository.get_revisions(revision_ids))
205
221
    for origin, text in annotations:
206
 
        text = text.rstrip(b'\r\n')
 
222
        text = text.rstrip('\r\n')
207
223
        if origin == last_origin:
208
 
            (revno_str, author, date_str) = ('', '', '')
 
224
            (revno_str, author, date_str) = ('','','')
209
225
        else:
210
226
            last_origin = origin
211
227
            if origin not in revisions:
212
 
                (revno_str, author, date_str) = ('?', '?', '?')
 
228
                (revno_str, author, date_str) = ('?','?','?')
213
229
            else:
214
230
                revno_str = '.'.join(str(i) for i in
215
231
                                            revision_id_to_revno[origin])
222
238
            author = rev.get_apparent_authors()[0]
223
239
            try:
224
240
                author = extract_email_address(author)
225
 
            except NoEmailInUsername:
 
241
            except errors.NoEmailInUsername:
226
242
                pass        # use the whole name
227
243
        yield (revno_str, author, date_str, origin, text)
228
244
 
296
312
 
297
313
 
298
314
def _get_matching_blocks(old, new):
299
 
    matcher = patiencediff.PatienceSequenceMatcher(None, old, new)
 
315
    matcher = patiencediff.PatienceSequenceMatcher(None,
 
316
        old, new)
300
317
    return matcher.get_matching_blocks()
301
318
 
302
319
 
349
366
    output_extend = output_lines.extend
350
367
    output_append = output_lines.append
351
368
    # We need to see if any of the unannotated lines match
352
 
    plain_right_subset = [l for a, l in right_lines[start_right:end_right]]
 
369
    plain_right_subset = [l for a,l in right_lines[start_right:end_right]]
353
370
    plain_child_subset = plain_child_lines[start_child:end_child]
354
371
    match_blocks = _get_matching_blocks(plain_right_subset, plain_child_subset)
355
372
 
360
377
        if child_idx > last_child_idx:
361
378
            output_extend(child_lines[start_child + last_child_idx
362
379
                                      :start_child + child_idx])
363
 
        for offset in range(match_len):
 
380
        for offset in xrange(match_len):
364
381
            left = child_lines[start_child+child_idx+offset]
365
382
            right = right_lines[start_right+right_idx+offset]
366
383
            if left[0] == right[0]:
377
394
                else:
378
395
                    heads = heads_provider.heads((left[0], right[0]))
379
396
                    if len(heads) == 1:
380
 
                        output_append((next(iter(heads)), left[1]))
 
397
                        output_append((iter(heads).next(), left[1]))
381
398
                    else:
382
399
                        # Both claim different origins, get a stable result.
383
400
                        # If the result is not stable, there is a risk a
440
457
 
441
458
 
442
459
try:
443
 
    from breezy._annotator_pyx import Annotator
444
 
except ImportError as e:
 
460
    from bzrlib._annotator_pyx import Annotator
 
461
except ImportError, e:
445
462
    osutils.failed_to_load_extension(e)
446
 
    from breezy._annotator_py import Annotator
 
463
    from bzrlib._annotator_py import Annotator