/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: Vincent Ladeuil
  • Date: 2007-11-24 14:20:59 UTC
  • mto: (3928.1.1 bzr.integration)
  • mto: This revision was merged to the branch mainline in revision 3929.
  • Revision ID: v.ladeuil+lp@free.fr-20071124142059-2114qtsgfdv8g9p1
Ssl files needed for the test https server.

* bzrlib/tests/ssl_certs/create_ssls.py: 
Script to create the ssl keys and certificates.

* bzrlib/tests/ssl_certs/server.crt: 
Server certificate signed by the certificate authority.

* bzrlib/tests/ssl_certs/server.csr: 
Server certificate signing request.

* bzrlib/tests/ssl_certs/server_without_pass.key: 
Server key usable without password.

* bzrlib/tests/ssl_certs/server_with_pass.key: 
Server key.

* bzrlib/tests/ssl_certs/ca.key: 
Certificate authority private key.

* bzrlib/tests/ssl_certs/ca.crt: 
Certificate authority certificate.

* bzrlib/tests/ssl_certs/__init__.py: 
Provide access to ssl files (keys and certificates). 

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
 
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
24
22
 
25
23
# TODO: Show which revision caused a line to merge into the parent
26
24
 
27
25
# TODO: perhaps abbreviate timescales depending on how recent they are
28
 
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.
 
26
# e.g. "3:12 Tue", "13 Oct", "Oct 2005", etc.  
29
27
 
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):
58
 
    """Annotate file_id in a tree.
59
 
 
60
 
    The tree should already be read_locked() when annotate_file_tree is called.
61
 
 
62
 
    :param tree: The tree to look for revision numbers and history from.
63
 
    :param path: The path to annotate
64
 
    :param to_file: The file to output the annotation to.
65
 
    :param verbose: Show all details rather than truncating to ensure
66
 
        reasonable text width.
67
 
    :param full: XXXX Not sure what this does.
68
 
    :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
 
    """
72
 
    if branch is None:
73
 
        branch = tree.branch
 
37
from bzrlib.config import extract_email_address
 
38
 
 
39
 
 
40
def annotate_file(branch, rev_id, file_id, verbose=False, full=False,
 
41
                  to_file=None, show_ids=False):
74
42
    if to_file is None:
75
43
        to_file = sys.stdout
76
44
 
77
45
    # Handle the show_ids case
78
 
    annotations = list(tree.annotate_iter(path, file_id))
 
46
    last_rev_id = None
79
47
    if show_ids:
80
 
        return _show_id_annotations(annotations, to_file, full)
81
 
 
82
 
    if not getattr(tree, "get_revision_id", False):
83
 
        # Create a virtual revision to represent the current tree state.
84
 
        # Should get some more pending commit attributes, like pending tags,
85
 
        # bugfixes etc.
86
 
        current_rev = Revision(CURRENT_REVISION)
87
 
        current_rev.parent_ids = tree.get_parent_ids()
88
 
        try:
89
 
            current_rev.committer = branch.get_config_stack().get('email')
90
 
        except NoWhoami:
91
 
            current_rev.committer = 'local user'
92
 
        current_rev.message = "?"
93
 
        current_rev.timestamp = round(time.time(), 3)
94
 
        current_rev.timezone = osutils.local_time_offset()
95
 
    else:
96
 
        current_rev = None
97
 
    annotation = list(_expand_annotations(annotations, branch,
98
 
        current_rev))
99
 
    _print_annotations(annotation, verbose, to_file, full)
100
 
 
101
 
 
102
 
def _print_annotations(annotation, verbose, to_file, full):
103
 
    """Print annotations to to_file.
104
 
 
105
 
    :param to_file: The file to output the annotation to.
106
 
    :param verbose: Show all details rather than truncating to ensure
107
 
        reasonable text width.
108
 
    :param full: XXXX Not sure what this does.
109
 
    """
 
48
        annotations = _annotations(branch.repository, file_id, rev_id)
 
49
        max_origin_len = max(len(origin) for origin, text in annotations)
 
50
        for origin, text in annotations:
 
51
            if full or last_rev_id != origin:
 
52
                this = origin
 
53
            else:
 
54
                this = ''
 
55
            to_file.write('%*s | %s' % (max_origin_len, this, text))
 
56
            last_rev_id = origin
 
57
        return
 
58
 
 
59
    # Calculate the lengths of the various columns
 
60
    annotation = list(_annotate_file(branch, rev_id, file_id))
110
61
    if len(annotation) == 0:
111
62
        max_origin_len = max_revno_len = max_revid_len = 0
112
63
    else:
119
70
 
120
71
    # Output the annotations
121
72
    prevanno = ''
 
73
    encoding = getattr(to_file, 'encoding', None) or \
 
74
            osutils.get_terminal_encoding()
122
75
    for (revno_str, author, date_str, line_rev_id, text) in annotation:
123
76
        if verbose:
124
77
            anno = '%-*s %-*s %8s ' % (max_revno_len, revno_str,
129
82
            anno = "%-*s %-7s " % (max_revno_len, revno_str, author[:7])
130
83
        if anno.lstrip() == "" and full:
131
84
            anno = prevanno
132
 
        # GZ 2017-05-21: Writing both unicode annotation and bytes from file
133
 
        # which the given to_file must cope with.
134
 
        to_file.write(anno)
 
85
        try:
 
86
            to_file.write(anno)
 
87
        except UnicodeEncodeError:
 
88
            # cmd_annotate should be passing in an 'exact' object, which means
 
89
            # we have a direct handle to sys.stdout or equivalent. It may not
 
90
            # be able to handle the exact Unicode characters, but 'annotate' is
 
91
            # a user function (non-scripting), so shouldn't die because of
 
92
            # unrepresentable annotation characters. So encode using 'replace',
 
93
            # and write them again.
 
94
            to_file.write(anno.encode(encoding, 'replace'))
135
95
        to_file.write('| %s\n' % (text,))
136
96
        prevanno = anno
137
97
 
138
98
 
139
 
def _show_id_annotations(annotations, to_file, full):
140
 
    if not annotations:
141
 
        return
142
 
    last_rev_id = None
143
 
    max_origin_len = max(len(origin) for origin, text in annotations)
144
 
    for origin, text in annotations:
145
 
        if full or last_rev_id != origin:
146
 
            this = origin
147
 
        else:
148
 
            this = ''
149
 
        to_file.write('%*s | %s' % (max_origin_len, this, text))
150
 
        last_rev_id = origin
151
 
    return
152
 
 
153
 
 
154
 
def _expand_annotations(annotations, branch, current_rev=None):
155
 
    """Expand a file's annotations into command line UI ready tuples.
156
 
 
157
 
    Each tuple includes detailed information, such as the author name, and date
158
 
    string for the commit, rather than just the revision id.
159
 
 
160
 
    :param annotations: The annotations to expand.
161
 
    :param revision_id_to_revno: A map from id to revision numbers.
162
 
    :param branch: A locked branch to query for revision details.
 
99
def _annotations(repo, file_id, rev_id):
 
100
    """Return the list of (origin,text) for a revision of a file in a repository."""
 
101
    w = repo.weave_store.get_weave(file_id, repo.get_transaction())
 
102
    return list(w.annotate_iter(rev_id))
 
103
 
 
104
 
 
105
def _annotate_file(branch, rev_id, file_id):
 
106
    """Yield the origins for each line of a file.
 
107
 
 
108
    This includes detailed information, such as the author name, and
 
109
    date string for the commit, rather than just the revision id.
163
110
    """
164
 
    repository = branch.repository
 
111
    revision_id_to_revno = branch.get_revision_id_to_revno_map()
 
112
    annotations = _annotations(branch.repository, file_id, rev_id)
 
113
    last_origin = None
165
114
    revision_ids = set(o for o, t in annotations)
166
 
    if current_rev is not None:
167
 
        # This can probably become a function on MutableTree, get_revno_map
168
 
        # there, or something.
169
 
        last_revision = current_rev.revision_id
170
 
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
171
 
        # XXX: The main difficulty is that we need to inject a single new node
172
 
        #      (current_rev) into the graph before it gets numbered, etc.
173
 
        #      Once KnownGraph gets an 'add_node()' function, we can use
174
 
        #      VF.get_known_graph_ancestry().
175
 
        graph = repository.get_graph()
176
 
        revision_graph = dict(((key, value) for key, value in
177
 
            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
178
 
        revision_graph = _strip_NULL_ghosts(revision_graph)
179
 
        revision_graph[last_revision] = current_rev.parent_ids
180
 
        merge_sorted_revisions = tsort.merge_sort(
181
 
            revision_graph,
182
 
            last_revision,
183
 
            None,
184
 
            generate_revno=True)
185
 
        revision_id_to_revno = dict((rev_id, revno)
186
 
            for seq_num, rev_id, depth, revno, end_of_merge in
187
 
                merge_sorted_revisions)
188
 
    else:
189
 
        # TODO(jelmer): Only look up the revision ids that we need (i.e. those
190
 
        # in revision_ids). Possibly add a HPSS call that can look those up
191
 
        # in bulk over HPSS.
192
 
        revision_id_to_revno = branch.get_revision_id_to_revno_map()
193
 
    last_origin = None
194
 
    revisions = {}
195
 
    if CURRENT_REVISION in revision_ids:
196
 
        revision_id_to_revno[CURRENT_REVISION] = (
197
 
            "%d?" % (branch.revno() + 1),)
198
 
        revisions[CURRENT_REVISION] = current_rev
199
 
    revisions.update(
200
 
            entry for entry in
201
 
            repository.iter_revisions(revision_ids)
202
 
            if entry[1] is not None)
 
115
    revision_ids = [o for o in revision_ids if 
 
116
                    branch.repository.has_revision(o)]
 
117
    revisions = dict((r.revision_id, r) for r in 
 
118
                     branch.repository.get_revisions(revision_ids))
203
119
    for origin, text in annotations:
204
 
        text = text.rstrip(b'\r\n')
 
120
        text = text.rstrip('\r\n')
205
121
        if origin == last_origin:
206
 
            (revno_str, author, date_str) = ('', '', '')
 
122
            (revno_str, author, date_str) = ('','','')
207
123
        else:
208
124
            last_origin = origin
209
125
            if origin not in revisions:
210
 
                (revno_str, author, date_str) = ('?', '?', '?')
 
126
                (revno_str, author, date_str) = ('?','?','?')
211
127
            else:
212
128
                revno_str = '.'.join(str(i) for i in
213
129
                                            revision_id_to_revno[origin])
217
133
                                     time.gmtime(rev.timestamp + tz))
218
134
            # a lazy way to get something like the email address
219
135
            # TODO: Get real email address
220
 
            author = rev.get_apparent_authors()[0]
 
136
            author = rev.get_apparent_author()
221
137
            try:
222
138
                author = extract_email_address(author)
223
 
            except NoEmailInUsername:
 
139
            except errors.NoEmailInUsername:
224
140
                pass        # use the whole name
225
141
        yield (revno_str, author, date_str, origin, text)
226
142
 
227
143
 
228
144
def reannotate(parents_lines, new_lines, new_revision_id,
229
 
               _left_matching_blocks=None,
230
 
               heads_provider=None):
 
145
               _left_matching_blocks=None):
231
146
    """Create a new annotated version from new lines and parent annotations.
232
 
 
 
147
    
233
148
    :param parents_lines: List of annotated lines for all parents
234
149
    :param new_lines: The un-annotated new lines
235
150
    :param new_revision_id: The revision-id to associate with new lines
236
151
        (will often be CURRENT_REVISION)
237
152
    :param left_matching_blocks: a hint about which areas are common
238
153
        between the text and its left-hand-parent.  The format is
239
 
        the SequenceMatcher.get_matching_blocks format
240
 
        (start_left, start_right, length_of_match).
241
 
    :param heads_provider: An object which provides a .heads() call to resolve
242
 
        if any revision ids are children of others.
243
 
        If None, then any ancestry disputes will be resolved with
244
 
        new_revision_id
 
154
        the SequenceMatcher.get_matching_blocks format.
245
155
    """
246
156
    if len(parents_lines) == 0:
247
 
        lines = [(new_revision_id, line) for line in new_lines]
 
157
        for line in new_lines:
 
158
            yield new_revision_id, line
248
159
    elif len(parents_lines) == 1:
249
 
        lines = _reannotate(parents_lines[0], new_lines, new_revision_id,
250
 
                            _left_matching_blocks)
251
 
    elif len(parents_lines) == 2:
252
 
        left = _reannotate(parents_lines[0], new_lines, new_revision_id,
253
 
                           _left_matching_blocks)
254
 
        lines = _reannotate_annotated(parents_lines[1], new_lines,
255
 
                                      new_revision_id, left,
256
 
                                      heads_provider)
 
160
        for data in _reannotate(parents_lines[0], new_lines, new_revision_id,
 
161
                                _left_matching_blocks):
 
162
            yield data
257
163
    else:
258
 
        reannotations = [_reannotate(parents_lines[0], new_lines,
259
 
                                     new_revision_id, _left_matching_blocks)]
260
 
        reannotations.extend(_reannotate(p, new_lines, new_revision_id)
261
 
                             for p in parents_lines[1:])
262
 
        lines = []
 
164
        block_list = [_left_matching_blocks] + [None] * len(parents_lines)
 
165
        reannotations = [list(_reannotate(p, new_lines, new_revision_id, b))
 
166
                         for p, b in zip(parents_lines, block_list)]
263
167
        for annos in zip(*reannotations):
264
168
            origins = set(a for a, l in annos)
 
169
            line = annos[0][1]
265
170
            if len(origins) == 1:
266
 
                # All the parents agree, so just return the first one
267
 
                lines.append(annos[0])
 
171
                yield iter(origins).next(), line
 
172
            elif len(origins) == 2 and new_revision_id in origins:
 
173
                yield (x for x in origins if x != new_revision_id).next(), line
268
174
            else:
269
 
                line = annos[0][1]
270
 
                if len(origins) == 2 and new_revision_id in origins:
271
 
                    origins.remove(new_revision_id)
272
 
                if len(origins) == 1:
273
 
                    lines.append((origins.pop(), line))
274
 
                else:
275
 
                    lines.append((new_revision_id, line))
276
 
    return lines
 
175
                yield new_revision_id, line
277
176
 
278
177
 
279
178
def _reannotate(parent_lines, new_lines, new_revision_id,
284
183
        matcher = patiencediff.PatienceSequenceMatcher(None,
285
184
            plain_parent_lines, new_lines)
286
185
        matching_blocks = matcher.get_matching_blocks()
287
 
    lines = []
288
186
    for i, j, n in matching_blocks:
289
187
        for line in new_lines[new_cur:j]:
290
 
            lines.append((new_revision_id, line))
291
 
        lines.extend(parent_lines[i:i+n])
 
188
            yield new_revision_id, line
 
189
        for data in parent_lines[i:i+n]:
 
190
            yield data
292
191
        new_cur = j + n
293
 
    return lines
294
 
 
295
 
 
296
 
def _get_matching_blocks(old, new):
297
 
    matcher = patiencediff.PatienceSequenceMatcher(None, old, new)
298
 
    return matcher.get_matching_blocks()
299
 
 
300
 
 
301
 
_break_annotation_tie = None
302
 
 
303
 
def _old_break_annotation_tie(annotated_lines):
304
 
    """Chose an attribution between several possible ones.
305
 
 
306
 
    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where
307
 
        the lines are identical but the revids different while no parent
308
 
        relation exist between them
309
 
 
310
 
     :return : The "winning" line. This must be one with a revid that
311
 
         guarantees that further criss-cross merges will converge. Failing to
312
 
         do so have performance implications.
313
 
    """
314
 
    # sort lexicographically so that we always get a stable result.
315
 
 
316
 
    # TODO: while 'sort' is the easiest (and nearly the only possible solution)
317
 
    # with the current implementation, chosing the oldest revision is known to
318
 
    # provide better results (as in matching user expectations). The most
319
 
    # common use case being manual cherry-pick from an already existing
320
 
    # revision.
321
 
    return sorted(annotated_lines)[0]
322
 
 
323
 
 
324
 
def _find_matching_unannotated_lines(output_lines, plain_child_lines,
325
 
                                     child_lines, start_child, end_child,
326
 
                                     right_lines, start_right, end_right,
327
 
                                     heads_provider, revision_id):
328
 
    """Find lines in plain_right_lines that match the existing lines.
329
 
 
330
 
    :param output_lines: Append final annotated lines to this list
331
 
    :param plain_child_lines: The unannotated new lines for the child text
332
 
    :param child_lines: Lines for the child text which have been annotated
333
 
        for the left parent
334
 
 
335
 
    :param start_child: Position in plain_child_lines and child_lines to start
336
 
        the match searching
337
 
    :param end_child: Last position in plain_child_lines and child_lines to
338
 
        search for a match
339
 
    :param right_lines: The annotated lines for the whole text for the right
340
 
        parent
341
 
    :param start_right: Position in right_lines to start the match
342
 
    :param end_right: Last position in right_lines to search for a match
343
 
    :param heads_provider: When parents disagree on the lineage of a line, we
344
 
        need to check if one side supersedes the other
345
 
    :param revision_id: The label to give if a line should be labeled 'tip'
346
 
    """
347
 
    output_extend = output_lines.extend
348
 
    output_append = output_lines.append
349
 
    # We need to see if any of the unannotated lines match
350
 
    plain_right_subset = [l for a, l in right_lines[start_right:end_right]]
351
 
    plain_child_subset = plain_child_lines[start_child:end_child]
352
 
    match_blocks = _get_matching_blocks(plain_right_subset, plain_child_subset)
353
 
 
354
 
    last_child_idx = 0
355
 
 
356
 
    for right_idx, child_idx, match_len in match_blocks:
357
 
        # All the lines that don't match are just passed along
358
 
        if child_idx > last_child_idx:
359
 
            output_extend(child_lines[start_child + last_child_idx
360
 
                                      :start_child + child_idx])
361
 
        for offset in range(match_len):
362
 
            left = child_lines[start_child+child_idx+offset]
363
 
            right = right_lines[start_right+right_idx+offset]
364
 
            if left[0] == right[0]:
365
 
                # The annotations match, just return the left one
366
 
                output_append(left)
367
 
            elif left[0] == revision_id:
368
 
                # The left parent marked this as unmatched, so let the
369
 
                # right parent claim it
370
 
                output_append(right)
371
 
            else:
372
 
                # Left and Right both claim this line
373
 
                if heads_provider is None:
374
 
                    output_append((revision_id, left[1]))
375
 
                else:
376
 
                    heads = heads_provider.heads((left[0], right[0]))
377
 
                    if len(heads) == 1:
378
 
                        output_append((next(iter(heads)), left[1]))
379
 
                    else:
380
 
                        # Both claim different origins, get a stable result.
381
 
                        # If the result is not stable, there is a risk a
382
 
                        # performance degradation as criss-cross merges will
383
 
                        # flip-flop the attribution.
384
 
                        if _break_annotation_tie is None:
385
 
                            output_append(
386
 
                                _old_break_annotation_tie([left, right]))
387
 
                        else:
388
 
                            output_append(_break_annotation_tie([left, right]))
389
 
        last_child_idx = child_idx + match_len
390
 
 
391
 
 
392
 
def _reannotate_annotated(right_parent_lines, new_lines, new_revision_id,
393
 
                          annotated_lines, heads_provider):
394
 
    """Update the annotations for a node based on another parent.
395
 
 
396
 
    :param right_parent_lines: A list of annotated lines for the right-hand
397
 
        parent.
398
 
    :param new_lines: The unannotated new lines.
399
 
    :param new_revision_id: The revision_id to attribute to lines which are not
400
 
        present in either parent.
401
 
    :param annotated_lines: A list of annotated lines. This should be the
402
 
        annotation of new_lines based on parents seen so far.
403
 
    :param heads_provider: When parents disagree on the lineage of a line, we
404
 
        need to check if one side supersedes the other.
405
 
    """
406
 
    if len(new_lines) != len(annotated_lines):
407
 
        raise AssertionError("mismatched new_lines and annotated_lines")
408
 
    # First compare the newly annotated lines with the right annotated lines.
409
 
    # Lines which were not changed in left or right should match. This tends to
410
 
    # be the bulk of the lines, and they will need no further processing.
411
 
    lines = []
412
 
    lines_extend = lines.extend
413
 
    last_right_idx = 0 # The line just after the last match from the right side
414
 
    last_left_idx = 0
415
 
    matching_left_and_right = _get_matching_blocks(right_parent_lines,
416
 
                                                   annotated_lines)
417
 
    for right_idx, left_idx, match_len in matching_left_and_right:
418
 
        # annotated lines from last_left_idx to left_idx did not match the
419
 
        # lines from last_right_idx to right_idx, the raw lines should be
420
 
        # compared to determine what annotations need to be updated
421
 
        if last_right_idx == right_idx or last_left_idx == left_idx:
422
 
            # One of the sides is empty, so this is a pure insertion
423
 
            lines_extend(annotated_lines[last_left_idx:left_idx])
424
 
        else:
425
 
            # We need to see if any of the unannotated lines match
426
 
            _find_matching_unannotated_lines(lines,
427
 
                                             new_lines, annotated_lines,
428
 
                                             last_left_idx, left_idx,
429
 
                                             right_parent_lines,
430
 
                                             last_right_idx, right_idx,
431
 
                                             heads_provider,
432
 
                                             new_revision_id)
433
 
        last_right_idx = right_idx + match_len
434
 
        last_left_idx = left_idx + match_len
435
 
        # If left and right agree on a range, just push that into the output
436
 
        lines_extend(annotated_lines[left_idx:left_idx + match_len])
437
 
    return lines
438
 
 
439
 
 
440
 
try:
441
 
    from breezy._annotator_pyx import Annotator
442
 
except ImportError as e:
443
 
    osutils.failed_to_load_extension(e)
444
 
    from breezy._annotator_py import Annotator