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

  • Committer: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/annotate.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
28
28
import sys
29
29
import time
30
30
 
31
 
from bzrlib import (
 
31
from .lazy_import import lazy_import
 
32
lazy_import(globals(), """
 
33
 
 
34
import patiencediff
 
35
 
 
36
from breezy import (
 
37
    tsort,
 
38
    )
 
39
""")
 
40
from . import (
 
41
    config,
32
42
    errors,
33
43
    osutils,
34
 
    patiencediff,
35
 
    tsort,
36
 
    )
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.
 
44
    )
 
45
from .repository import _strip_NULL_ghosts
 
46
from .revision import (
 
47
    CURRENT_REVISION,
 
48
    Revision,
 
49
    )
 
50
 
 
51
 
 
52
def annotate_file_tree(tree, path, to_file, verbose=False, full=False,
 
53
                       show_ids=False, branch=None):
 
54
    """Annotate path in a tree.
 
55
 
 
56
    The tree should already be read_locked() when annotate_file_tree is called.
 
57
 
 
58
    :param tree: The tree to look for revision numbers and history from.
 
59
    :param path: The path to annotate
 
60
    :param to_file: The file to output the annotation to.
51
61
    :param verbose: Show all details rather than truncating to ensure
52
62
        reasonable text width.
53
63
    :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
64
    :param show_ids: Show revision ids in the annotation output.
 
65
    :param branch: Branch to use for revision revno lookups
57
66
    """
 
67
    if branch is None:
 
68
        branch = tree.branch
58
69
    if to_file is None:
59
70
        to_file = sys.stdout
60
71
 
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):
73
 
    """Annotate file_id in a tree.
74
 
 
75
 
    The tree should already be read_locked() when annotate_file_tree is called.
76
 
 
77
 
    :param tree: The tree to look for revision numbers and history from.
78
 
    :param file_id: The file_id to annotate.
79
 
    :param to_file: The file to output the annotation to.
80
 
    :param verbose: Show all details rather than truncating to ensure
81
 
        reasonable text width.
82
 
    :param full: XXXX Not sure what this does.
83
 
    :param show_ids: Show revision ids in the annotation output.
84
 
    """
85
 
    rev_id = tree.last_revision()
86
 
    branch = tree.branch
87
 
 
88
 
    # Handle the show_ids case
89
 
    annotations = list(tree.annotate_iter(file_id))
90
 
    if show_ids:
91
 
        return _show_id_annotations(annotations, to_file, full)
92
 
 
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,
103
 
        current_rev))
104
 
    _print_annotations(annotation, verbose, to_file, full)
105
 
 
106
 
 
107
 
def _print_annotations(annotation, verbose, to_file, full):
 
72
    encoding = osutils.get_terminal_encoding()
 
73
    # Handle the show_ids case
 
74
    annotations = list(tree.annotate_iter(path))
 
75
    if show_ids:
 
76
        return _show_id_annotations(annotations, to_file, full, encoding)
 
77
 
 
78
    if not getattr(tree, "get_revision_id", False):
 
79
        # Create a virtual revision to represent the current tree state.
 
80
        # Should get some more pending commit attributes, like pending tags,
 
81
        # bugfixes etc.
 
82
        current_rev = Revision(CURRENT_REVISION)
 
83
        current_rev.parent_ids = tree.get_parent_ids()
 
84
        try:
 
85
            current_rev.committer = branch.get_config_stack().get('email')
 
86
        except errors.NoWhoami:
 
87
            current_rev.committer = 'local user'
 
88
        current_rev.message = "?"
 
89
        current_rev.timestamp = round(time.time(), 3)
 
90
        current_rev.timezone = osutils.local_time_offset()
 
91
    else:
 
92
        current_rev = None
 
93
    annotation = list(_expand_annotations(
 
94
        annotations, branch, current_rev))
 
95
    _print_annotations(annotation, verbose, to_file, full, encoding)
 
96
 
 
97
 
 
98
def _print_annotations(annotation, verbose, to_file, full, encoding):
108
99
    """Print annotations to to_file.
109
100
 
110
101
    :param to_file: The file to output the annotation to.
113
104
    :param full: XXXX Not sure what this does.
114
105
    """
115
106
    if len(annotation) == 0:
116
 
        max_origin_len = max_revno_len = max_revid_len = 0
 
107
        max_origin_len = max_revno_len = 0
117
108
    else:
118
109
        max_origin_len = max(len(x[1]) for x in annotation)
119
110
        max_revno_len = max(len(x[0]) for x in annotation)
120
 
        max_revid_len = max(len(x[3]) for x in annotation)
121
111
    if not verbose:
122
112
        max_revno_len = min(max_revno_len, 12)
123
113
    max_revno_len = max(max_revno_len, 3)
124
114
 
125
115
    # Output the annotations
126
116
    prevanno = ''
127
 
    encoding = getattr(to_file, 'encoding', None) or \
128
 
            osutils.get_terminal_encoding()
129
117
    for (revno_str, author, date_str, line_rev_id, text) in annotation:
130
118
        if verbose:
131
119
            anno = '%-*s %-*s %8s ' % (max_revno_len, revno_str,
132
120
                                       max_origin_len, author, date_str)
133
121
        else:
134
122
            if len(revno_str) > max_revno_len:
135
 
                revno_str = revno_str[:max_revno_len-1] + '>'
 
123
                revno_str = revno_str[:max_revno_len - 1] + '>'
136
124
            anno = "%-*s %-7s " % (max_revno_len, revno_str, author[:7])
137
125
        if anno.lstrip() == "" and full:
138
126
            anno = prevanno
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,))
 
127
        # GZ 2017-05-21: Writing both unicode annotation and bytes from file
 
128
        # which the given to_file must cope with.
 
129
        to_file.write(anno)
 
130
        to_file.write('| %s\n' % (text.decode(encoding),))
150
131
        prevanno = anno
151
132
 
152
133
 
153
 
def _show_id_annotations(annotations, to_file, full):
 
134
def _show_id_annotations(annotations, to_file, full, encoding):
154
135
    if not annotations:
155
136
        return
156
137
    last_rev_id = None
159
140
        if full or last_rev_id != origin:
160
141
            this = origin
161
142
        else:
162
 
            this = ''
163
 
        to_file.write('%*s | %s' % (max_origin_len, this, text))
 
143
            this = b''
 
144
        to_file.write('%*s | %s' % (
 
145
            max_origin_len, this.decode('utf-8'), text.decode(encoding)))
164
146
        last_rev_id = origin
165
147
    return
166
148
 
167
149
 
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
 
 
175
150
def _expand_annotations(annotations, branch, current_rev=None):
176
151
    """Expand a file's annotations into command line UI ready tuples.
177
152
 
183
158
    :param branch: A locked branch to query for revision details.
184
159
    """
185
160
    repository = branch.repository
 
161
    revision_ids = set(o for o, t in annotations)
186
162
    if current_rev is not None:
187
 
        # This can probably become a function on MutableTree, get_revno_map there,
188
 
        # or something.
 
163
        # This can probably become a function on MutableTree, get_revno_map
 
164
        # there, or something.
189
165
        last_revision = current_rev.revision_id
190
166
        # XXX: Partially Cloned from branch, uses the old_get_graph, eep.
191
167
        # XXX: The main difficulty is that we need to inject a single new node
193
169
        #      Once KnownGraph gets an 'add_node()' function, we can use
194
170
        #      VF.get_known_graph_ancestry().
195
171
        graph = repository.get_graph()
196
 
        revision_graph = dict(((key, value) for key, value in
197
 
            graph.iter_ancestry(current_rev.parent_ids) if value is not None))
 
172
        revision_graph = {
 
173
            key: value for key, value in
 
174
            graph.iter_ancestry(current_rev.parent_ids) if value is not None}
198
175
        revision_graph = _strip_NULL_ghosts(revision_graph)
199
176
        revision_graph[last_revision] = current_rev.parent_ids
200
177
        merge_sorted_revisions = tsort.merge_sort(
202
179
            last_revision,
203
180
            None,
204
181
            generate_revno=True)
205
 
        revision_id_to_revno = dict((rev_id, revno)
 
182
        revision_id_to_revno = {
 
183
            rev_id: revno
206
184
            for seq_num, rev_id, depth, revno, end_of_merge in
207
 
                merge_sorted_revisions)
 
185
            merge_sorted_revisions}
208
186
    else:
 
187
        # TODO(jelmer): Only look up the revision ids that we need (i.e. those
 
188
        # in revision_ids). Possibly add a HPSS call that can look those up
 
189
        # in bulk over HPSS.
209
190
        revision_id_to_revno = branch.get_revision_id_to_revno_map()
210
191
    last_origin = None
211
 
    revision_ids = set(o for o, t in annotations)
212
192
    revisions = {}
213
193
    if CURRENT_REVISION in revision_ids:
214
194
        revision_id_to_revno[CURRENT_REVISION] = (
215
195
            "%d?" % (branch.revno() + 1),)
216
196
        revisions[CURRENT_REVISION] = current_rev
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))
 
197
    revisions.update(
 
198
        entry for entry in
 
199
        repository.iter_revisions(revision_ids)
 
200
        if entry[1] is not None)
221
201
    for origin, text in annotations:
222
 
        text = text.rstrip('\r\n')
 
202
        text = text.rstrip(b'\r\n')
223
203
        if origin == last_origin:
224
 
            (revno_str, author, date_str) = ('','','')
 
204
            (revno_str, author, date_str) = ('', '', '')
225
205
        else:
226
206
            last_origin = origin
227
207
            if origin not in revisions:
228
 
                (revno_str, author, date_str) = ('?','?','?')
 
208
                (revno_str, author, date_str) = ('?', '?', '?')
229
209
            else:
230
 
                revno_str = '.'.join(str(i) for i in
231
 
                                            revision_id_to_revno[origin])
 
210
                revno_str = '.'.join(
 
211
                    str(i) for i in revision_id_to_revno[origin])
232
212
            rev = revisions[origin]
233
213
            tz = rev.timezone or 0
234
214
            date_str = time.strftime('%Y%m%d',
236
216
            # a lazy way to get something like the email address
237
217
            # TODO: Get real email address
238
218
            author = rev.get_apparent_authors()[0]
239
 
            try:
240
 
                author = extract_email_address(author)
241
 
            except errors.NoEmailInUsername:
242
 
                pass        # use the whole name
 
219
            _, email = config.parse_username(author)
 
220
            if email:
 
221
                author = email
243
222
        yield (revno_str, author, date_str, origin, text)
244
223
 
245
224
 
299
278
    new_cur = 0
300
279
    if matching_blocks is None:
301
280
        plain_parent_lines = [l for r, l in parent_lines]
302
 
        matcher = patiencediff.PatienceSequenceMatcher(None,
303
 
            plain_parent_lines, new_lines)
 
281
        matcher = patiencediff.PatienceSequenceMatcher(
 
282
            None, plain_parent_lines, new_lines)
304
283
        matching_blocks = matcher.get_matching_blocks()
305
284
    lines = []
306
285
    for i, j, n in matching_blocks:
307
286
        for line in new_lines[new_cur:j]:
308
287
            lines.append((new_revision_id, line))
309
 
        lines.extend(parent_lines[i:i+n])
 
288
        lines.extend(parent_lines[i:i + n])
310
289
        new_cur = j + n
311
290
    return lines
312
291
 
313
292
 
314
293
def _get_matching_blocks(old, new):
315
 
    matcher = patiencediff.PatienceSequenceMatcher(None,
316
 
        old, new)
 
294
    matcher = patiencediff.PatienceSequenceMatcher(None, old, new)
317
295
    return matcher.get_matching_blocks()
318
296
 
319
297
 
320
298
_break_annotation_tie = None
321
299
 
 
300
 
322
301
def _old_break_annotation_tie(annotated_lines):
323
302
    """Chose an attribution between several possible ones.
324
303
 
366
345
    output_extend = output_lines.extend
367
346
    output_append = output_lines.append
368
347
    # We need to see if any of the unannotated lines match
369
 
    plain_right_subset = [l for a,l in right_lines[start_right:end_right]]
 
348
    plain_right_subset = [l for a, l in right_lines[start_right:end_right]]
370
349
    plain_child_subset = plain_child_lines[start_child:end_child]
371
350
    match_blocks = _get_matching_blocks(plain_right_subset, plain_child_subset)
372
351
 
375
354
    for right_idx, child_idx, match_len in match_blocks:
376
355
        # All the lines that don't match are just passed along
377
356
        if child_idx > last_child_idx:
378
 
            output_extend(child_lines[start_child + last_child_idx
379
 
                                      :start_child + child_idx])
380
 
        for offset in xrange(match_len):
381
 
            left = child_lines[start_child+child_idx+offset]
382
 
            right = right_lines[start_right+right_idx+offset]
 
357
            output_extend(child_lines[start_child + last_child_idx:
 
358
                                      start_child + child_idx])
 
359
        for offset in range(match_len):
 
360
            left = child_lines[start_child + child_idx + offset]
 
361
            right = right_lines[start_right + right_idx + offset]
383
362
            if left[0] == right[0]:
384
363
                # The annotations match, just return the left one
385
364
                output_append(left)
394
373
                else:
395
374
                    heads = heads_provider.heads((left[0], right[0]))
396
375
                    if len(heads) == 1:
397
 
                        output_append((iter(heads).next(), left[1]))
 
376
                        output_append((next(iter(heads)), left[1]))
398
377
                    else:
399
378
                        # Both claim different origins, get a stable result.
400
379
                        # If the result is not stable, there is a risk a
429
408
    # be the bulk of the lines, and they will need no further processing.
430
409
    lines = []
431
410
    lines_extend = lines.extend
432
 
    last_right_idx = 0 # The line just after the last match from the right side
 
411
    # The line just after the last match from the right side
 
412
    last_right_idx = 0
433
413
    last_left_idx = 0
434
414
    matching_left_and_right = _get_matching_blocks(right_parent_lines,
435
415
                                                   annotated_lines)
457
437
 
458
438
 
459
439
try:
460
 
    from bzrlib._annotator_pyx import Annotator
461
 
except ImportError, e:
 
440
    from breezy._annotator_pyx import Annotator
 
441
except ImportError as e:
462
442
    osutils.failed_to_load_extension(e)
463
 
    from bzrlib._annotator_py import Annotator
 
443
    from breezy._annotator_py import Annotator  # noqa: F401