1
=== modified file '.bzrignore'
2
--- .bzrignore	2009-06-22 12:52:39 +0000
3
+++ .bzrignore	2009-07-08 23:35:26 +0000
4
@@ -38,6 +38,7 @@
5
38
./api
38
./api
6
39
doc/**/*.html
39
doc/**/*.html
7
40
doc/developers/performance.png
40
doc/developers/performance.png
8
41
bzrlib/_annotator_pyx.c
9
41
bzrlib/_bencode_pyx.c
42
bzrlib/_bencode_pyx.c
10
42
bzrlib/_btree_serializer_pyx.c
43
bzrlib/_btree_serializer_pyx.c
11
43
bzrlib/_chk_map_pyx.c
44
bzrlib/_chk_map_pyx.c
12
44
45
13
=== modified file 'NEWS'
14
--- NEWS	2009-07-08 18:05:38 +0000
15
+++ NEWS	2009-07-08 23:35:27 +0000
16
@@ -48,6 +48,9 @@
17
48
  diverged-branches`` when a push fails because the branches have
48
  diverged-branches`` when a push fails because the branches have
18
49
  diverged.  (Neil Martinsen-Burrell, #269477)
49
  diverged.  (Neil Martinsen-Burrell, #269477)
19
50
50
20
51
* Annotate would sometimes 'latch on' to trivial lines, causing important
21
52
  lines to be incorrectly annotated. (John Arbash Meinel, #387952)
22
53
23
51
* Automatic format upgrades triggered by default stacking policies on a
54
* Automatic format upgrades triggered by default stacking policies on a
24
52
  1.16rc1 (or later) smart server work again.
55
  1.16rc1 (or later) smart server work again.
25
53
  (Andrew Bennetts, #388675)
56
  (Andrew Bennetts, #388675)
26
@@ -164,7 +167,12 @@
27
164
Improvements
167
Improvements
28
165
************
168
************
29
166
169
31
167
``bzr ls`` is now faster. On OpenOffice.org, the time drops from 2.4
170
* ``bzr annotate`` can now be significantly faster. The time for
32
171
  ``bzr annotate NEWS`` is down to 7s from 22s in 1.16. Files with long
33
172
  histories and lots of 'duplicate insertions' will be improved more than
34
173
  others. (John Arbash Meinel, Vincent Ladeuil)
35
174
36
175
* ``bzr ls`` is now faster. On OpenOffice.org, the time drops from 2.4
37
168
  to 1.1 seconds. The improvement for ``bzr ls -r-1`` is more
176
  to 1.1 seconds. The improvement for ``bzr ls -r-1`` is more
38
169
  substantial dropping from 54.3 to 1.1 seconds. (Ian Clatworthy)
177
  substantial dropping from 54.3 to 1.1 seconds. (Ian Clatworthy)
39
170
178
40
171
179
41
=== added file 'bzrlib/_annotator_py.py'
42
--- bzrlib/_annotator_py.py	1970-01-01 00:00:00 +0000
43
+++ bzrlib/_annotator_py.py	2009-07-08 23:35:27 +0000
44
@@ -0,0 +1,309 @@
45
1
# Copyright (C) 2009 Canonical Ltd
46
2
#
47
3
# This program is free software; you can redistribute it and/or modify
48
4
# it under the terms of the GNU General Public License as published by
49
5
# the Free Software Foundation; either version 2 of the License, or
50
6
# (at your option) any later version.
51
7
#
52
8
# This program is distributed in the hope that it will be useful,
53
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
54
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
55
11
# GNU General Public License for more details.
56
12
#
57
13
# You should have received a copy of the GNU General Public License
58
14
# along with this program; if not, write to the Free Software
59
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
60
16
61
17
"""Functionality for doing annotations in the 'optimal' way"""
62
18
63
19
from bzrlib.lazy_import import lazy_import
64
20
lazy_import(globals(), """
65
21
from bzrlib import annotate # Must be lazy to avoid circular importing
66
22
""")
67
23
from bzrlib import (
68
24
    errors,
69
25
    graph as _mod_graph,
70
26
    osutils,
71
27
    patiencediff,
72
28
    ui,
73
29
    )
74
30
75
31
76
32
class Annotator(object):
77
33
    """Class that drives performing annotations."""
78
34
79
35
    def __init__(self, vf):
80
36
        """Create a new Annotator from a VersionedFile."""
81
37
        self._vf = vf
82
38
        self._parent_map = {}
83
39
        self._text_cache = {}
84
40
        # Map from key => number of nexts that will be built from this key
85
41
        self._num_needed_children = {}
86
42
        self._annotations_cache = {}
87
43
        self._heads_provider = None
88
44
        self._ann_tuple_cache = {}
89
45
90
46
    def _update_needed_children(self, key, parent_keys):
91
47
        for parent_key in parent_keys:
92
48
            if parent_key in self._num_needed_children:
93
49
                self._num_needed_children[parent_key] += 1
94
50
            else:
95
51
                self._num_needed_children[parent_key] = 1
96
52
97
53
    def _get_needed_keys(self, key):
98
54
        """Determine the texts we need to get from the backing vf.
99
55
100
56
        :return: (vf_keys_needed, ann_keys_needed)
101
57
            vf_keys_needed  These are keys that we need to get from the vf
102
58
            ann_keys_needed Texts which we have in self._text_cache but we
103
59
                            don't have annotations for. We need to yield these
104
60
                            in the proper order so that we can get proper
105
61
                            annotations.
106
62
        """
107
63
        parent_map = self._parent_map
108
64
        # We need 1 extra copy of the node we will be looking at when we are
109
65
        # done
110
66
        self._num_needed_children[key] = 1
111
67
        vf_keys_needed = set()
112
68
        ann_keys_needed = set()
113
69
        needed_keys = set([key])
114
70
        while needed_keys:
115
71
            parent_lookup = []
116
72
            next_parent_map = {}
117
73
            for key in needed_keys:
118
74
                if key in self._parent_map:
119
75
                    # We don't need to lookup this key in the vf
120
76
                    if key not in self._text_cache:
121
77
                        # Extract this text from the vf
122
78
                        vf_keys_needed.add(key)
123
79
                    elif key not in self._annotations_cache:
124
80
                        # We do need to annotate
125
81
                        ann_keys_needed.add(key)
126
82
                        next_parent_map[key] = self._parent_map[key]
127
83
                else:
128
84
                    parent_lookup.append(key)
129
85
                    vf_keys_needed.add(key)
130
86
            needed_keys = set()
131
87
            next_parent_map.update(self._vf.get_parent_map(parent_lookup))
132
88
            for key, parent_keys in next_parent_map.iteritems():
133
89
                if parent_keys is None: # No graph versionedfile
134
90
                    parent_keys = ()
135
91
                    next_parent_map[key] = ()
136
92
                self._update_needed_children(key, parent_keys)
137
93
                needed_keys.update([key for key in parent_keys
138
94
                                         if key not in parent_map])
139
95
            parent_map.update(next_parent_map)
140
96
            # _heads_provider does some graph caching, so it is only valid while
141
97
            # self._parent_map hasn't changed
142
98
            self._heads_provider = None
143
99
        return vf_keys_needed, ann_keys_needed
144
100
145
101
    def _get_needed_texts(self, key, pb=None):
146
102
        """Get the texts we need to properly annotate key.
147
103
148
104
        :param key: A Key that is present in self._vf
149
105
        :return: Yield (this_key, text, num_lines)
150
106
            'text' is an opaque object that just has to work with whatever
151
107
            matcher object we are using. Currently it is always 'lines' but
152
108
            future improvements may change this to a simple text string.
153
109
        """
154
110
        keys, ann_keys = self._get_needed_keys(key)
155
111
        if pb is not None:
156
112
            pb.update('getting stream', 0, len(keys))
157
113
        stream  = self._vf.get_record_stream(keys, 'topological', True)
158
114
        for idx, record in enumerate(stream):
159
115
            if pb is not None:
160
116
                pb.update('extracting', 0, len(keys))
161
117
            if record.storage_kind == 'absent':
162
118
                raise errors.RevisionNotPresent(record.key, self._vf)
163
119
            this_key = record.key
164
120
            lines = osutils.chunks_to_lines(record.get_bytes_as('chunked'))
165
121
            num_lines = len(lines)
166
122
            self._text_cache[this_key] = lines
167
123
            yield this_key, lines, num_lines
168
124
        for key in ann_keys:
169
125
            lines = self._text_cache[key]
170
126
            num_lines = len(lines)
171
127
            yield key, lines, num_lines
172
128
173
129
    def _get_parent_annotations_and_matches(self, key, text, parent_key):
174
130
        """Get the list of annotations for the parent, and the matching lines.
175
131
176
132
        :param text: The opaque value given by _get_needed_texts
177
133
        :param parent_key: The key for the parent text
178
134
        :return: (parent_annotations, matching_blocks)
179
135
            parent_annotations is a list as long as the number of lines in
180
136
                parent
181
137
            matching_blocks is a list of (parent_idx, text_idx, len) tuples
182
138
                indicating which lines match between the two texts
183
139
        """
184
140
        parent_lines = self._text_cache[parent_key]
185
141
        parent_annotations = self._annotations_cache[parent_key]
186
142
        # PatienceSequenceMatcher should probably be part of Policy
187
143
        matcher = patiencediff.PatienceSequenceMatcher(None,
188
144
            parent_lines, text)
189
145
        matching_blocks = matcher.get_matching_blocks()
190
146
        return parent_annotations, matching_blocks
191
147
192
148
    def _update_from_first_parent(self, key, annotations, lines, parent_key):
193
149
        """Reannotate this text relative to its first parent."""
194
150
        (parent_annotations,
195
151
         matching_blocks) = self._get_parent_annotations_and_matches(
196
152
                                key, lines, parent_key)
197
153
198
154
        for parent_idx, lines_idx, match_len in matching_blocks:
199
155
            # For all matching regions we copy across the parent annotations
200
156
            annotations[lines_idx:lines_idx + match_len] = \
201
157
                parent_annotations[parent_idx:parent_idx + match_len]
202
158
203
159
    def _update_from_other_parents(self, key, annotations, lines,
204
160
                                   this_annotation, parent_key):
205
161
        """Reannotate this text relative to a second (or more) parent."""
206
162
        (parent_annotations,
207
163
         matching_blocks) = self._get_parent_annotations_and_matches(
208
164
                                key, lines, parent_key)
209
165
210
166
        last_ann = None
211
167
        last_parent = None
212
168
        last_res = None
213
169
        # TODO: consider making all annotations unique and then using 'is'
214
170
        #       everywhere. Current results claim that isn't any faster,
215
171
        #       because of the time spent deduping
216
172
        #       deduping also saves a bit of memory. For NEWS it saves ~1MB,
217
173
        #       but that is out of 200-300MB for extracting everything, so a
218
174
        #       fairly trivial amount
219
175
        for parent_idx, lines_idx, match_len in matching_blocks:
220
176
            # For lines which match this parent, we will now resolve whether
221
177
            # this parent wins over the current annotation
222
178
            ann_sub = annotations[lines_idx:lines_idx + match_len]
223
179
            par_sub = parent_annotations[parent_idx:parent_idx + match_len]
224
180
            if ann_sub == par_sub:
225
181
                continue
226
182
            for idx in xrange(match_len):
227
183
                ann = ann_sub[idx]
228
184
                par_ann = par_sub[idx]
229
185
                ann_idx = lines_idx + idx
230
186
                if ann == par_ann:
231
187
                    # Nothing to change
232
188
                    continue
233
189
                if ann == this_annotation:
234
190
                    # Originally claimed 'this', but it was really in this
235
191
                    # parent
236
192
                    annotations[ann_idx] = par_ann
237
193
                    continue
238
194
                # Resolve the fact that both sides have a different value for
239
195
                # last modified
240
196
                if ann == last_ann and par_ann == last_parent:
241
197
                    annotations[ann_idx] = last_res
242
198
                else:
243
199
                    new_ann = set(ann)
244
200
                    new_ann.update(par_ann)
245
201
                    new_ann = tuple(sorted(new_ann))
246
202
                    annotations[ann_idx] = new_ann
247
203
                    last_ann = ann
248
204
                    last_parent = par_ann
249
205
                    last_res = new_ann
250
206
251
207
    def _record_annotation(self, key, parent_keys, annotations):
252
208
        self._annotations_cache[key] = annotations
253
209
        for parent_key in parent_keys:
254
210
            num = self._num_needed_children[parent_key]
255
211
            num -= 1
256
212
            if num == 0:
257
213
                del self._text_cache[parent_key]
258
214
                del self._annotations_cache[parent_key]
259
215
                # Do we want to clean up _num_needed_children at this point as
260
216
                # well?
261
217
            self._num_needed_children[parent_key] = num
262
218
263
219
    def _annotate_one(self, key, text, num_lines):
264
220
        this_annotation = (key,)
265
221
        # Note: annotations will be mutated by calls to _update_from*
266
222
        annotations = [this_annotation] * num_lines
267
223
        parent_keys = self._parent_map[key]
268
224
        if parent_keys:
269
225
            self._update_from_first_parent(key, annotations, text,
270
226
                                           parent_keys[0])
271
227
            for parent in parent_keys[1:]:
272
228
                self._update_from_other_parents(key, annotations, text,
273
229
                                                this_annotation, parent)
274
230
        self._record_annotation(key, parent_keys, annotations)
275
231
276
232
    def add_special_text(self, key, parent_keys, text):
277
233
        """Add a specific text to the graph.
278
234
279
235
        This is used to add a text which is not otherwise present in the
280
236
        versioned file. (eg. a WorkingTree injecting 'current:' into the
281
237
        graph to annotate the edited content.)
282
238
283
239
        :param key: The key to use to request this text be annotated
284
240
        :param parent_keys: The parents of this text
285
241
        :param text: A string containing the content of the text
286
242
        """
287
243
        self._parent_map[key] = parent_keys
288
244
        self._text_cache[key] = osutils.split_lines(text)
289
245
        self._heads_provider = None
290
246
291
247
    def annotate(self, key):
292
248
        """Return annotated fulltext for the given key.
293
249
294
250
        :param key: A tuple defining the text to annotate
295
251
        :return: ([annotations], [lines])
296
252
            annotations is a list of tuples of keys, one for each line in lines
297
253
                        each key is a possible source for the given line.
298
254
            lines the text of "key" as a list of lines
299
255
        """
300
256
        pb = ui.ui_factory.nested_progress_bar()
301
257
        try:
302
258
            for text_key, text, num_lines in self._get_needed_texts(key, pb=pb):
303
259
                self._annotate_one(text_key, text, num_lines)
304
260
        finally:
305
261
            pb.finished()
306
262
        try:
307
263
            annotations = self._annotations_cache[key]
308
264
        except KeyError:
309
265
            raise errors.RevisionNotPresent(key, self._vf)
310
266
        return annotations, self._text_cache[key]
311
267
312
268
    def _get_heads_provider(self):
313
269
        if self._heads_provider is None:
314
270
            self._heads_provider = _mod_graph.KnownGraph(self._parent_map)
315
271
        return self._heads_provider
316
272
317
273
    def _resolve_annotation_tie(self, the_heads, line, tiebreaker):
318
274
        if tiebreaker is None:
319
275
            head = sorted(the_heads)[0]
320
276
        else:
321
277
            # Backwards compatibility, break up the heads into pairs and
322
278
            # resolve the result
323
279
            next_head = iter(the_heads)
324
280
            head = next_head.next()
325
281
            for possible_head in next_head:
326
282
                annotated_lines = ((head, line), (possible_head, line))
327
283
                head = tiebreaker(annotated_lines)[0]
328
284
        return head
329
285
330
286
    def annotate_flat(self, key):
331
287
        """Determine the single-best-revision to source for each line.
332
288
333
289
        This is meant as a compatibility thunk to how annotate() used to work.
334
290
        :return: [(ann_key, line)]
335
291
            A list of tuples with a single annotation key for each line.
336
292
        """
337
293
        custom_tiebreaker = annotate._break_annotation_tie
338
294
        annotations, lines = self.annotate(key)
339
295
        out = []
340
296
        heads = self._get_heads_provider().heads
341
297
        append = out.append
342
298
        for annotation, line in zip(annotations, lines):
343
299
            if len(annotation) == 1:
344
300
                head = annotation[0]
345
301
            else:
346
302
                the_heads = heads(annotation)
347
303
                if len(the_heads) == 1:
348
304
                    for head in the_heads: break # get the item out of the set
349
305
                else:
350
306
                    head = self._resolve_annotation_tie(the_heads, line,
351
307
                                                        custom_tiebreaker)
352
308
            append((head, line))
353
309
        return out
354
0
310
355
=== added file 'bzrlib/_annotator_pyx.pyx'
356
--- bzrlib/_annotator_pyx.pyx	1970-01-01 00:00:00 +0000
357
+++ bzrlib/_annotator_pyx.pyx	2009-07-08 23:35:27 +0000
358
@@ -0,0 +1,287 @@
359
1
# Copyright (C) 2009 Canonical Ltd
360
2
#
361
3
# This program is free software; you can redistribute it and/or modify
362
4
# it under the terms of the GNU General Public License as published by
363
5
# the Free Software Foundation; either version 2 of the License, or
364
6
# (at your option) any later version.
365
7
#
366
8
# This program is distributed in the hope that it will be useful,
367
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
368
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
369
11
# GNU General Public License for more details.
370
12
#
371
13
# You should have received a copy of the GNU General Public License
372
14
# along with this program; if not, write to the Free Software
373
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
374
16
375
17
"""Functionality for doing annotations in the 'optimal' way"""
376
18
377
19
cdef extern from "python-compat.h":
378
20
    pass
379
21
380
22
cdef extern from "Python.h":
381
23
    ctypedef int Py_ssize_t
382
24
    ctypedef struct PyObject:
383
25
        pass
384
26
    ctypedef struct PyListObject:
385
27
        PyObject **ob_item
386
28
    int PyList_CheckExact(object)
387
29
    PyObject *PyList_GET_ITEM(object, Py_ssize_t o)
388
30
    Py_ssize_t PyList_GET_SIZE(object)
389
31
    int PyList_Append(object, object) except -1
390
32
    int PyList_SetItem(object, Py_ssize_t o, object) except -1
391
33
    int PyList_Sort(object) except -1
392
34
393
35
    int PyTuple_CheckExact(object)
394
36
    object PyTuple_New(Py_ssize_t len)
395
37
    void PyTuple_SET_ITEM(object, Py_ssize_t pos, object)
396
38
    void PyTuple_SET_ITEM_ptr "PyTuple_SET_ITEM" (object, Py_ssize_t,
397
39
                                                  PyObject *)
398
40
    int PyTuple_Resize(PyObject **, Py_ssize_t newlen)
399
41
    PyObject *PyTuple_GET_ITEM(object, Py_ssize_t o)
400
42
    Py_ssize_t PyTuple_GET_SIZE(object)
401
43
402
44
    PyObject *PyDict_GetItem(object d, object k)
403
45
    int PyDict_SetItem(object d, object k, object v) except -1
404
46
405
47
    void Py_INCREF(object)
406
48
    void Py_INCREF_ptr "Py_INCREF" (PyObject *)
407
49
    void Py_DECREF_ptr "Py_DECREF" (PyObject *)
408
50
409
51
    int Py_EQ
410
52
    int Py_LT
411
53
    int PyObject_RichCompareBool(object, object, int opid) except -1
412
54
    int PyObject_RichCompareBool_ptr "PyObject_RichCompareBool" (
413
55
        PyObject *, PyObject *, int opid)
414
56
415
57
416
58
from bzrlib import _annotator_py
417
59
418
60
419
61
cdef int _check_annotations_are_lists(annotations,
420
62
                                      parent_annotations) except -1:
421
63
    if not PyList_CheckExact(annotations):
422
64
        raise TypeError('annotations must be a list')
423
65
    if not PyList_CheckExact(parent_annotations):
424
66
        raise TypeError('parent_annotations must be a list')
425
67
    return 0
426
68
427
69
428
70
cdef int _check_match_ranges(parent_annotations, annotations,
429
71
                             Py_ssize_t parent_idx, Py_ssize_t lines_idx,
430
72
                             Py_ssize_t match_len) except -1:
431
73
    if parent_idx + match_len > PyList_GET_SIZE(parent_annotations):
432
74
        raise ValueError('Match length exceeds len of'
433
75
                         ' parent_annotations %s > %s'
434
76
                         % (parent_idx + match_len,
435
77
                            PyList_GET_SIZE(parent_annotations)))
436
78
    if lines_idx + match_len > PyList_GET_SIZE(annotations):
437
79
        raise ValueError('Match length exceeds len of'
438
80
                         ' annotations %s > %s'
439
81
                         % (lines_idx + match_len,
440
82
                            PyList_GET_SIZE(annotations)))
441
83
    return 0
442
84
443
85
444
86
cdef PyObject *_next_tuple_entry(object tpl, Py_ssize_t *pos):
445
87
    pos[0] = pos[0] + 1
446
88
    if pos[0] >= PyTuple_GET_SIZE(tpl):
447
89
        return NULL
448
90
    return PyTuple_GET_ITEM(tpl, pos[0])
449
91
450
92
451
93
cdef object _combine_annotations(ann_one, ann_two, cache):
452
94
    """Combine the annotations from both sides."""
453
95
    cdef Py_ssize_t pos_one, pos_two, len_one, len_two
454
96
    cdef Py_ssize_t out_pos
455
97
    cdef PyObject *temp, *left, *right
456
98
457
99
    if (PyObject_RichCompareBool(ann_one, ann_two, Py_LT)):
458
100
        cache_key = (ann_one, ann_two)
459
101
    else:
460
102
        cache_key = (ann_two, ann_one)
461
103
    temp = PyDict_GetItem(cache, cache_key)
462
104
    if temp != NULL:
463
105
        return <object>temp
464
106
465
107
    if not PyTuple_CheckExact(ann_one) or not PyTuple_CheckExact(ann_two):
466
108
        raise TypeError('annotations must be tuples')
467
109
    # We know that annotations are tuples, and that both sides are already
468
110
    # sorted, so we can just walk and update a new list.
469
111
    pos_one = -1
470
112
    pos_two = -1
471
113
    out_pos = 0
472
114
    left = _next_tuple_entry(ann_one, &pos_one)
473
115
    right = _next_tuple_entry(ann_two, &pos_two)
474
116
    new_ann = PyTuple_New(PyTuple_GET_SIZE(ann_one)
475
117
                          + PyTuple_GET_SIZE(ann_two))
476
118
    while left != NULL and right != NULL:
477
119
        # left == right is done by PyObject_RichCompareBool_ptr, however it
478
120
        # avoids a function call for a very common case. Drops 'time bzr
479
121
        # annotate NEWS' from 7.25s to 7.16s, so it *is* a visible impact.
480
122
        if (left == right
481
123
            or PyObject_RichCompareBool_ptr(left, right, Py_EQ)):
482
124
            # Identical values, step both
483
125
            Py_INCREF_ptr(left)
484
126
            PyTuple_SET_ITEM_ptr(new_ann, out_pos, left)
485
127
            left = _next_tuple_entry(ann_one, &pos_one)
486
128
            right = _next_tuple_entry(ann_two, &pos_two)
487
129
        elif (PyObject_RichCompareBool_ptr(left, right, Py_LT)):
488
130
            # left < right or right == NULL
489
131
            Py_INCREF_ptr(left)
490
132
            PyTuple_SET_ITEM_ptr(new_ann, out_pos, left)
491
133
            left = _next_tuple_entry(ann_one, &pos_one)
492
134
        else: # right < left or left == NULL
493
135
            Py_INCREF_ptr(right)
494
136
            PyTuple_SET_ITEM_ptr(new_ann, out_pos, right)
495
137
            right = _next_tuple_entry(ann_two, &pos_two)
496
138
        out_pos = out_pos + 1
497
139
    while left != NULL:
498
140
        Py_INCREF_ptr(left)
499
141
        PyTuple_SET_ITEM_ptr(new_ann, out_pos, left)
500
142
        left = _next_tuple_entry(ann_one, &pos_one)
501
143
        out_pos = out_pos + 1
502
144
    while right != NULL:
503
145
        Py_INCREF_ptr(right)
504
146
        PyTuple_SET_ITEM_ptr(new_ann, out_pos, right)
505
147
        right = _next_tuple_entry(ann_two, &pos_two)
506
148
        out_pos = out_pos + 1
507
149
    if out_pos != PyTuple_GET_SIZE(new_ann):
508
150
        # Timing _PyTuple_Resize was not significantly faster that slicing
509
151
        # PyTuple_Resize((<PyObject **>new_ann), out_pos)
510
152
        new_ann = new_ann[0:out_pos]
511
153
    PyDict_SetItem(cache, cache_key, new_ann)
512
154
    return new_ann
513
155
514
156
515
157
cdef int _apply_parent_annotations(annotations, parent_annotations,
516
158
                                   matching_blocks) except -1:
517
159
    """Apply the annotations from parent_annotations into annotations.
518
160
519
161
    matching_blocks defines the ranges that match.
520
162
    """
521
163
    cdef Py_ssize_t parent_idx, lines_idx, match_len, idx
522
164
    cdef PyListObject *par_list, *ann_list
523
165
    cdef PyObject **par_temp, **ann_temp
524
166
525
167
    _check_annotations_are_lists(annotations, parent_annotations)
526
168
    par_list = <PyListObject *>parent_annotations
527
169
    ann_list = <PyListObject *>annotations
528
170
    # For NEWS and bzrlib/builtins.py, over 99% of the lines are simply copied
529
171
    # across from the parent entry. So this routine is heavily optimized for
530
172
    # that. Would be interesting if we could use memcpy() but we have to incref
531
173
    # and decref
532
174
    for parent_idx, lines_idx, match_len in matching_blocks:
533
175
        _check_match_ranges(parent_annotations, annotations,
534
176
                            parent_idx, lines_idx, match_len)
535
177
        par_temp = par_list.ob_item + parent_idx
536
178
        ann_temp = ann_list.ob_item + lines_idx
537
179
        for idx from 0 <= idx < match_len:
538
180
            Py_INCREF_ptr(par_temp[idx])
539
181
            Py_DECREF_ptr(ann_temp[idx])
540
182
            ann_temp[idx] = par_temp[idx]
541
183
    return 0
542
184
543
185
544
186
cdef int _merge_annotations(this_annotation, annotations, parent_annotations,
545
187
                            matching_blocks, ann_cache) except -1:
546
188
    cdef Py_ssize_t parent_idx, ann_idx, lines_idx, match_len, idx
547
189
    cdef Py_ssize_t pos
548
190
    cdef PyObject *ann_temp, *par_temp
549
191
550
192
    _check_annotations_are_lists(annotations, parent_annotations)
551
193
    last_ann = None
552
194
    last_parent = None
553
195
    last_res = None
554
196
    for parent_idx, lines_idx, match_len in matching_blocks:
555
197
        _check_match_ranges(parent_annotations, annotations,
556
198
                            parent_idx, lines_idx, match_len)
557
199
        # For lines which match this parent, we will now resolve whether
558
200
        # this parent wins over the current annotation
559
201
        for idx from 0 <= idx < match_len:
560
202
            ann_idx = lines_idx + idx
561
203
            ann_temp = PyList_GET_ITEM(annotations, ann_idx)
562
204
            par_temp = PyList_GET_ITEM(parent_annotations, parent_idx + idx)
563
205
            if (ann_temp == par_temp):
564
206
                # This is parent, do nothing
565
207
                # Pointer comparison is fine here. Value comparison would
566
208
                # be ok, but it will be handled in the final if clause by
567
209
                # merging the two tuples into the same tuple
568
210
                # Avoiding the Py_INCREF and function call to
569
211
                # PyObject_RichCompareBool using pointer comparison drops
570
212
                # timing from 215ms => 125ms
571
213
                continue
572
214
            par_ann = <object>par_temp
573
215
            ann = <object>ann_temp
574
216
            if (ann is this_annotation):
575
217
                # Originally claimed 'this', but it was really in this
576
218
                # parent
577
219
                Py_INCREF(par_ann)
578
220
                PyList_SetItem(annotations, ann_idx, par_ann)
579
221
                continue
580
222
            # Resolve the fact that both sides have a different value for
581
223
            # last modified
582
224
            if (ann is last_ann and par_ann is last_parent):
583
225
                Py_INCREF(last_res)
584
226
                PyList_SetItem(annotations, ann_idx, last_res)
585
227
            else:
586
228
                new_ann = _combine_annotations(ann, par_ann, ann_cache)
587
229
                Py_INCREF(new_ann)
588
230
                PyList_SetItem(annotations, ann_idx, new_ann)
589
231
                last_ann = ann
590
232
                last_parent = par_ann
591
233
                last_res = new_ann
592
234
    return 0
593
235
594
236
595
237
class Annotator(_annotator_py.Annotator):
596
238
    """Class that drives performing annotations."""
597
239
598
240
    def _update_from_first_parent(self, key, annotations, lines, parent_key):
599
241
        """Reannotate this text relative to its first parent."""
600
242
        (parent_annotations,
601
243
         matching_blocks) = self._get_parent_annotations_and_matches(
602
244
                                key, lines, parent_key)
603
245
604
246
        _apply_parent_annotations(annotations, parent_annotations,
605
247
                                  matching_blocks)
606
248
607
249
    def _update_from_other_parents(self, key, annotations, lines,
608
250
                                   this_annotation, parent_key):
609
251
        """Reannotate this text relative to a second (or more) parent."""
610
252
        (parent_annotations,
611
253
         matching_blocks) = self._get_parent_annotations_and_matches(
612
254
                                key, lines, parent_key)
613
255
        _merge_annotations(this_annotation, annotations, parent_annotations,
614
256
                           matching_blocks, self._ann_tuple_cache)
615
257
616
258
    def annotate_flat(self, key):
617
259
        """Determine the single-best-revision to source for each line.
618
260
619
261
        This is meant as a compatibility thunk to how annotate() used to work.
620
262
        """
621
263
        cdef Py_ssize_t pos, num_lines
622
264
623
265
        from bzrlib import annotate
624
266
625
267
        custom_tiebreaker = annotate._break_annotation_tie
626
268
        annotations, lines = self.annotate(key)
627
269
        num_lines = len(lines)
628
270
        out = []
629
271
        heads = self._get_heads_provider().heads
630
272
        for pos from 0 <= pos < num_lines:
631
273
            annotation = annotations[pos]
632
274
            line = lines[pos]
633
275
            if len(annotation) == 1:
634
276
                head = annotation[0]
635
277
            else:
636
278
                the_heads = heads(annotation)
637
279
                if len(the_heads) == 1:
638
280
                    for head in the_heads: break # get the item out of the set
639
281
                else:
640
282
                    # We need to resolve the ambiguity, for now just pick the
641
283
                    # sorted smallest
642
284
                    head = self._resolve_annotation_tie(the_heads, line,
643
285
                                                        custom_tiebreaker)
644
286
            PyList_Append(out, (head, line))
645
287
        return out
646
0
288
647
=== modified file 'bzrlib/_known_graph_py.py'
648
--- bzrlib/_known_graph_py.py	2009-06-19 17:40:59 +0000
649
+++ bzrlib/_known_graph_py.py	2009-07-08 23:35:27 +0000
650
@@ -63,18 +63,12 @@
651
63
        - ghosts will have a parent_keys = None,
63
        - ghosts will have a parent_keys = None,
652
64
        - all nodes found will also have .child_keys populated with all known
64
        - all nodes found will also have .child_keys populated with all known
653
65
          child_keys,
65
          child_keys,
654
66
        - self._tails will list all the nodes without parents.
655
67
        """
66
        """
656
68
        tails = self._tails = set()
657
69
        nodes = self._nodes
67
        nodes = self._nodes
658
70
        for key, parent_keys in parent_map.iteritems():
68
        for key, parent_keys in parent_map.iteritems():
659
71
            if key in nodes:
69
            if key in nodes:
660
72
                node = nodes[key]
70
                node = nodes[key]
661
73
                node.parent_keys = parent_keys
71
                node.parent_keys = parent_keys
662
74
                if parent_keys:
663
75
                    # This node has been added before being seen in parent_map
664
76
                    # (see below)
665
77
                    tails.remove(node)
666
78
            else:
72
            else:
667
79
                node = _KnownGraphNode(key, parent_keys)
73
                node = _KnownGraphNode(key, parent_keys)
668
80
                nodes[key] = node
74
                nodes[key] = node
669
@@ -84,17 +78,18 @@
670
84
                except KeyError:
78
                except KeyError:
671
85
                    parent_node = _KnownGraphNode(parent_key, None)
79
                    parent_node = _KnownGraphNode(parent_key, None)
672
86
                    nodes[parent_key] = parent_node
80
                    nodes[parent_key] = parent_node
673
87
                    # Potentially a tail, if we're wrong we'll remove it later
674
88
                    # (see above)
675
89
                    tails.add(parent_node)
676
90
                parent_node.child_keys.append(key)
81
                parent_node.child_keys.append(key)
677
91
82
678
83
    def _find_tails(self):
679
84
        return [node for node in self._nodes.itervalues()
680
85
                if not node.parent_keys]
681
86
682
92
    def _find_gdfo(self):
87
    def _find_gdfo(self):
683
93
        nodes = self._nodes
88
        nodes = self._nodes
684
94
        known_parent_gdfos = {}
89
        known_parent_gdfos = {}
685
95
        pending = []
90
        pending = []
686
96
91
688
97
        for node in self._tails:
92
        for node in self._find_tails():
689
98
            node.gdfo = 1
93
            node.gdfo = 1
690
99
            pending.append(node)
94
            pending.append(node)
691
100
95
692
@@ -144,9 +139,6 @@
693
144
            # No or only one candidate
139
            # No or only one candidate
694
145
            return frozenset(candidate_nodes)
140
            return frozenset(candidate_nodes)
695
146
        heads_key = frozenset(candidate_nodes)
141
        heads_key = frozenset(candidate_nodes)
696
147
        if heads_key != frozenset(keys):
697
148
            # Mention duplicates
698
149
            note('%s != %s', heads_key, frozenset(keys))
699
150
        # Do we have a cached result ?
142
        # Do we have a cached result ?
700
151
        try:
143
        try:
701
152
            heads = self._known_heads[heads_key]
144
            heads = self._known_heads[heads_key]
702
153
145
703
=== modified file 'bzrlib/annotate.py'
704
--- bzrlib/annotate.py	2009-04-08 13:13:30 +0000
705
+++ bzrlib/annotate.py	2009-07-08 23:35:27 +0000
706
@@ -1,4 +1,4 @@
708
1
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
709
2
#
2
#
710
3
# This program is free software; you can redistribute it and/or modify
3
# This program is free software; you can redistribute it and/or modify
711
4
# it under the terms of the GNU General Public License as published by
4
# it under the terms of the GNU General Public License as published by
712
@@ -313,7 +313,9 @@
713
313
    return matcher.get_matching_blocks()
313
    return matcher.get_matching_blocks()
714
314
314
715
315
315
717
316
def _break_annotation_tie(annotated_lines):
316
_break_annotation_tie = None
718
317
719
318
def _old_break_annotation_tie(annotated_lines):
720
317
    """Chose an attribution between several possible ones.
319
    """Chose an attribution between several possible ones.
721
318
320
722
319
    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where
321
    :param annotated_lines: A list of tuples ((file_id, rev_id), line) where
723
@@ -394,7 +396,11 @@
724
394
                        # If the result is not stable, there is a risk a
396
                        # If the result is not stable, there is a risk a
725
395
                        # performance degradation as criss-cross merges will
397
                        # performance degradation as criss-cross merges will
726
396
                        # flip-flop the attribution.
398
                        # flip-flop the attribution.
728
397
                        output_append(_break_annotation_tie([left, right]))
399
                        if _break_annotation_tie is None:
729
400
                            output_append(
730
401
                                _old_break_annotation_tie([left, right]))
731
402
                        else:
732
403
                            output_append(_break_annotation_tie([left, right]))
733
398
        last_child_idx = child_idx + match_len
404
        last_child_idx = child_idx + match_len
734
399
405
735
400
406
736
@@ -444,3 +450,9 @@
737
444
        # If left and right agree on a range, just push that into the output
450
        # If left and right agree on a range, just push that into the output
738
445
        lines_extend(annotated_lines[left_idx:left_idx + match_len])
451
        lines_extend(annotated_lines[left_idx:left_idx + match_len])
739
446
    return lines
452
    return lines
740
453
741
454
742
455
try:
743
456
    from bzrlib._annotator_pyx import Annotator
744
457
except ImportError:
745
458
    from bzrlib._annotator_py import Annotator
746
447
459
747
=== modified file 'bzrlib/branchbuilder.py'
748
--- bzrlib/branchbuilder.py	2009-05-07 05:08:46 +0000
749
+++ bzrlib/branchbuilder.py	2009-07-08 23:35:27 +0000
750
@@ -161,7 +161,8 @@
751
161
        self._tree = None
161
        self._tree = None
752
162
162
753
163
    def build_snapshot(self, revision_id, parent_ids, actions,
163
    def build_snapshot(self, revision_id, parent_ids, actions,
755
164
        message=None, timestamp=None, allow_leftmost_as_ghost=False):
164
        message=None, timestamp=None, allow_leftmost_as_ghost=False,
756
165
        committer=None):
757
165
        """Build a commit, shaped in a specific way.
166
        """Build a commit, shaped in a specific way.
758
166
167
759
167
        :param revision_id: The handle for the new commit, can be None
168
        :param revision_id: The handle for the new commit, can be None
760
@@ -176,6 +177,7 @@
761
176
            commit message will be written.
177
            commit message will be written.
762
177
        :param timestamp: If non-None, set the timestamp of the commit to this
178
        :param timestamp: If non-None, set the timestamp of the commit to this
763
178
            value.
179
            value.
764
180
        :param committer: An optional username to use for commit
765
179
        :param allow_leftmost_as_ghost: True if the leftmost parent should be
181
        :param allow_leftmost_as_ghost: True if the leftmost parent should be
766
180
            permitted to be a ghost.
182
            permitted to be a ghost.
767
181
        :return: The revision_id of the new commit
183
        :return: The revision_id of the new commit
768
@@ -241,7 +243,7 @@
769
241
            for file_id, content in new_contents.iteritems():
243
            for file_id, content in new_contents.iteritems():
770
242
                tree.put_file_bytes_non_atomic(file_id, content)
244
                tree.put_file_bytes_non_atomic(file_id, content)
771
243
            return self._do_commit(tree, message=message, rev_id=revision_id,
245
            return self._do_commit(tree, message=message, rev_id=revision_id,
773
244
                timestamp=timestamp)
246
                timestamp=timestamp, committer=committer)
774
245
        finally:
247
        finally:
775
246
            tree.unlock()
248
            tree.unlock()
776
247
249
777
248
250
778
=== modified file 'bzrlib/groupcompress.py'
779
--- bzrlib/groupcompress.py	2009-07-01 10:47:37 +0000
780
+++ bzrlib/groupcompress.py	2009-07-08 23:35:27 +0000
781
@@ -1069,29 +1069,11 @@
782
1069
1069
783
1070
    def annotate(self, key):
1070
    def annotate(self, key):
784
1071
        """See VersionedFiles.annotate."""
1071
        """See VersionedFiles.annotate."""
808
1072
        graph = Graph(self)
1072
        ann = annotate.Annotator(self)
809
1073
        parent_map = self.get_parent_map([key])
1073
        return ann.annotate_flat(key)
810
1074
        if not parent_map:
1074
811
1075
            raise errors.RevisionNotPresent(key, self)
1075
    def get_annotator(self):
812
1076
        if parent_map[key] is not None:
1076
        return annotate.Annotator(self)
790
1077
            parent_map = dict((k, v) for k, v in graph.iter_ancestry([key])
791
1078
                              if v is not None)
792
1079
            keys = parent_map.keys()
793
1080
        else:
794
1081
            keys = [key]
795
1082
            parent_map = {key:()}
796
1083
        # We used Graph(self) to load the parent_map, but now that we have it,
797
1084
        # we can just query the parent map directly, so create a KnownGraph
798
1085
        heads_provider = _mod_graph.KnownGraph(parent_map)
799
1086
        parent_cache = {}
800
1087
        reannotate = annotate.reannotate
801
1088
        for record in self.get_record_stream(keys, 'topological', True):
802
1089
            key = record.key
803
1090
            lines = osutils.chunks_to_lines(record.get_bytes_as('chunked'))
804
1091
            parent_lines = [parent_cache[parent] for parent in parent_map[key]]
805
1092
            parent_cache[key] = list(
806
1093
                reannotate(parent_lines, lines, key, None, heads_provider))
807
1094
        return parent_cache[key]
813
1095
1077
814
1096
    def check(self, progress_bar=None):
1078
    def check(self, progress_bar=None):
815
1097
        """See VersionedFiles.check()."""
1079
        """See VersionedFiles.check()."""
816
1098
1080
817
=== modified file 'bzrlib/knit.py'
818
--- bzrlib/knit.py	2009-06-23 15:27:50 +0000
819
+++ bzrlib/knit.py	2009-07-08 23:35:27 +0000
820
@@ -664,8 +664,6 @@
821
664
664
822
665
        see parse_fulltext which this inverts.
665
        see parse_fulltext which this inverts.
823
666
        """
666
        """
824
667
        # TODO: jam 20070209 We only do the caching thing to make sure that
825
668
        #       the origin is a valid utf-8 line, eventually we could remove it
826
669
        return ['%s %s' % (o, t) for o, t in content._lines]
667
        return ['%s %s' % (o, t) for o, t in content._lines]
827
670
668
828
671
    def lower_line_delta(self, delta):
669
    def lower_line_delta(self, delta):
829
@@ -758,7 +756,7 @@
830
758
756
831
759
    def annotate(self, knit, key):
757
    def annotate(self, knit, key):
832
760
        annotator = _KnitAnnotator(knit)
758
        annotator = _KnitAnnotator(knit)
834
761
        return annotator.annotate(key)
759
        return annotator.annotate_flat(key)
835
762
760
836
763
761
837
764
762
838
@@ -1044,6 +1042,9 @@
839
1044
        """See VersionedFiles.annotate."""
1042
        """See VersionedFiles.annotate."""
840
1045
        return self._factory.annotate(self, key)
1043
        return self._factory.annotate(self, key)
841
1046
1044
842
1045
    def get_annotator(self):
843
1046
        return _KnitAnnotator(self)
844
1047
845
1047
    def check(self, progress_bar=None):
1048
    def check(self, progress_bar=None):
846
1048
        """See VersionedFiles.check()."""
1049
        """See VersionedFiles.check()."""
847
1049
        # This doesn't actually test extraction of everything, but that will
1050
        # This doesn't actually test extraction of everything, but that will
848
@@ -3336,103 +3337,33 @@
849
3336
    recommended.
3337
    recommended.
850
3337
    """
3338
    """
851
3338
    annotator = _KnitAnnotator(knit)
3339
    annotator = _KnitAnnotator(knit)
856
3339
    return iter(annotator.annotate(revision_id))
3340
    return iter(annotator.annotate_flat(revision_id))
857
3340
3341
858
3341
3342
859
3342
class _KnitAnnotator(object):
3343
class _KnitAnnotator(annotate.Annotator):
860
3343
    """Build up the annotations for a text."""
3344
    """Build up the annotations for a text."""
861
3344
3345
885
3345
    def __init__(self, knit):
3346
    def __init__(self, vf):
886
3346
        self._knit = knit
3347
        annotate.Annotator.__init__(self, vf)
887
3347
3348
888
3348
        # Content objects, differs from fulltexts because of how final newlines
3349
        # TODO: handle Nodes which cannot be extracted
889
3349
        # are treated by knits. the content objects here will always have a
3350
        # self._ghosts = set()
890
3350
        # final newline
3351
891
3351
        self._fulltext_contents = {}
3352
        # Map from (key, parent_key) => matching_blocks, should be 'use once'
892
3352
3353
        self._matching_blocks = {}
893
3353
        # Annotated lines of specific revisions
3354
894
3354
        self._annotated_lines = {}
3355
        # KnitContent objects
895
3355
3356
        self._content_objects = {}
896
3356
        # Track the raw data for nodes that we could not process yet.
3357
        # The number of children that depend on this fulltext content object
897
3357
        # This maps the revision_id of the base to a list of children that will
3358
        self._num_compression_children = {}
898
3358
        # annotated from it.
3359
        # Delta records that need their compression parent before they can be
899
3359
        self._pending_children = {}
3360
        # expanded
900
3360
3361
        self._pending_deltas = {}
901
3361
        # Nodes which cannot be extracted
3362
        # Fulltext records that are waiting for their parents fulltexts before
902
3362
        self._ghosts = set()
3363
        # they can be yielded for annotation
903
3363
3364
        self._pending_annotation = {}
881
3364
        # Track how many children this node has, so we know if we need to keep
882
3365
        # it
883
3366
        self._annotate_children = {}
884
3367
        self._compression_children = {}
904
3368
3365
905
3369
        self._all_build_details = {}
3366
        self._all_build_details = {}
906
3370
        # The children => parent revision_id graph
907
3371
        self._revision_id_graph = {}
908
3372
909
3373
        self._heads_provider = None
910
3374
911
3375
        self._nodes_to_keep_annotations = set()
912
3376
        self._generations_until_keep = 100
913
3377
914
3378
    def set_generations_until_keep(self, value):
915
3379
        """Set the number of generations before caching a node.
916
3380
917
3381
        Setting this to -1 will cache every merge node, setting this higher
918
3382
        will cache fewer nodes.
919
3383
        """
920
3384
        self._generations_until_keep = value
921
3385
922
3386
    def _add_fulltext_content(self, revision_id, content_obj):
923
3387
        self._fulltext_contents[revision_id] = content_obj
924
3388
        # TODO: jam 20080305 It might be good to check the sha1digest here
925
3389
        return content_obj.text()
926
3390
927
3391
    def _check_parents(self, child, nodes_to_annotate):
928
3392
        """Check if all parents have been processed.
929
3393
930
3394
        :param child: A tuple of (rev_id, parents, raw_content)
931
3395
        :param nodes_to_annotate: If child is ready, add it to
932
3396
            nodes_to_annotate, otherwise put it back in self._pending_children
933
3397
        """
934
3398
        for parent_id in child[1]:
935
3399
            if (parent_id not in self._annotated_lines):
936
3400
                # This parent is present, but another parent is missing
937
3401
                self._pending_children.setdefault(parent_id,
938
3402
                                                  []).append(child)
939
3403
                break
940
3404
        else:
941
3405
            # This one is ready to be processed
942
3406
            nodes_to_annotate.append(child)
943
3407
944
3408
    def _add_annotation(self, revision_id, fulltext, parent_ids,
945
3409
                        left_matching_blocks=None):
946
3410
        """Add an annotation entry.
947
3411
948
3412
        All parents should already have been annotated.
949
3413
        :return: A list of children that now have their parents satisfied.
950
3414
        """
951
3415
        a = self._annotated_lines
952
3416
        annotated_parent_lines = [a[p] for p in parent_ids]
953
3417
        annotated_lines = list(annotate.reannotate(annotated_parent_lines,
954
3418
            fulltext, revision_id, left_matching_blocks,
955
3419
            heads_provider=self._get_heads_provider()))
956
3420
        self._annotated_lines[revision_id] = annotated_lines
957
3421
        for p in parent_ids:
958
3422
            ann_children = self._annotate_children[p]
959
3423
            ann_children.remove(revision_id)
960
3424
            if (not ann_children
961
3425
                and p not in self._nodes_to_keep_annotations):
962
3426
                del self._annotated_lines[p]
963
3427
                del self._all_build_details[p]
964
3428
                if p in self._fulltext_contents:
965
3429
                    del self._fulltext_contents[p]
966
3430
        # Now that we've added this one, see if there are any pending
967
3431
        # deltas to be done, certainly this parent is finished
968
3432
        nodes_to_annotate = []
969
3433
        for child in self._pending_children.pop(revision_id, []):
970
3434
            self._check_parents(child, nodes_to_annotate)
971
3435
        return nodes_to_annotate
972
3436
3367
973
3437
    def _get_build_graph(self, key):
3368
    def _get_build_graph(self, key):
974
3438
        """Get the graphs for building texts and annotations.
3369
        """Get the graphs for building texts and annotations.
975
@@ -3446,202 +3377,243 @@
976
3446
            passing to read_records_iter to start reading in the raw data from
3377
            passing to read_records_iter to start reading in the raw data from
977
3447
            the pack file.
3378
            the pack file.
978
3448
        """
3379
        """
979
3449
        if key in self._annotated_lines:
980
3450
            # Nothing to do
981
3451
            return []
982
3452
        pending = set([key])
3380
        pending = set([key])
983
3453
        records = []
3381
        records = []
986
3454
        generation = 0
3382
        ann_keys = set()
987
3455
        kept_generation = 0
3383
        self._num_needed_children[key] = 1
988
3456
        while pending:
3384
        while pending:
989
3457
            # get all pending nodes
3385
            # get all pending nodes
990
3458
            generation += 1
991
3459
            this_iteration = pending
3386
            this_iteration = pending
993
3460
            build_details = self._knit._index.get_build_details(this_iteration)
3387
            build_details = self._vf._index.get_build_details(this_iteration)
994
3461
            self._all_build_details.update(build_details)
3388
            self._all_build_details.update(build_details)
996
3462
            # new_nodes = self._knit._index._get_entries(this_iteration)
3389
            # new_nodes = self._vf._index._get_entries(this_iteration)
997
3463
            pending = set()
3390
            pending = set()
998
3464
            for key, details in build_details.iteritems():
3391
            for key, details in build_details.iteritems():
1000
3465
                (index_memo, compression_parent, parents,
3392
                (index_memo, compression_parent, parent_keys,
1001
3466
                 record_details) = details
3393
                 record_details) = details
1003
3467
                self._revision_id_graph[key] = parents
3394
                self._parent_map[key] = parent_keys
1004
3395
                self._heads_provider = None
1005
3468
                records.append((key, index_memo))
3396
                records.append((key, index_memo))
1006
3469
                # Do we actually need to check _annotated_lines?
3397
                # Do we actually need to check _annotated_lines?
1009
3470
                pending.update(p for p in parents
3398
                pending.update([p for p in parent_keys
1010
3471
                                 if p not in self._all_build_details)
3399
                                   if p not in self._all_build_details])
1011
3400
                if parent_keys:
1012
3401
                    for parent_key in parent_keys:
1013
3402
                        if parent_key in self._num_needed_children:
1014
3403
                            self._num_needed_children[parent_key] += 1
1015
3404
                        else:
1016
3405
                            self._num_needed_children[parent_key] = 1
1017
3472
                if compression_parent:
3406
                if compression_parent:
1029
3473
                    self._compression_children.setdefault(compression_parent,
3407
                    if compression_parent in self._num_compression_children:
1030
3474
                        []).append(key)
3408
                        self._num_compression_children[compression_parent] += 1
1031
3475
                if parents:
3409
                    else:
1032
3476
                    for parent in parents:
3410
                        self._num_compression_children[compression_parent] = 1
1022
3477
                        self._annotate_children.setdefault(parent,
1023
3478
                            []).append(key)
1024
3479
                    num_gens = generation - kept_generation
1025
3480
                    if ((num_gens >= self._generations_until_keep)
1026
3481
                        and len(parents) > 1):
1027
3482
                        kept_generation = generation
1028
3483
                        self._nodes_to_keep_annotations.add(key)
1033
3484
3411
1034
3485
            missing_versions = this_iteration.difference(build_details.keys())
3412
            missing_versions = this_iteration.difference(build_details.keys())
1052
3486
            self._ghosts.update(missing_versions)
3413
            if missing_versions:
1053
3487
            for missing_version in missing_versions:
3414
                for key in missing_versions:
1054
3488
                # add a key, no parents
3415
                    if key in self._parent_map and key in self._text_cache:
1055
3489
                self._revision_id_graph[missing_version] = ()
3416
                        # We already have this text ready, we just need to
1056
3490
                pending.discard(missing_version) # don't look for it
3417
                        # yield it later so we get it annotated
1057
3491
        if self._ghosts.intersection(self._compression_children):
3418
                        ann_keys.add(key)
1058
3492
            raise KnitCorrupt(
3419
                        parent_keys = self._parent_map[key]
1059
3493
                "We cannot have nodes which have a ghost compression parent:\n"
3420
                        for parent_key in parent_keys:
1060
3494
                "ghosts: %r\n"
3421
                            if parent_key in self._num_needed_children:
1061
3495
                "compression children: %r"
3422
                                self._num_needed_children[parent_key] += 1
1062
3496
                % (self._ghosts, self._compression_children))
3423
                            else:
1063
3497
        # Cleanout anything that depends on a ghost so that we don't wait for
3424
                                self._num_needed_children[parent_key] = 1
1064
3498
        # the ghost to show up
3425
                        pending.update([p for p in parent_keys
1065
3499
        for node in self._ghosts:
3426
                                           if p not in self._all_build_details])
1066
3500
            if node in self._annotate_children:
3427
                    else:
1067
3501
                # We won't be building this node
3428
                        raise errors.RevisionNotPresent(key, self._vf)
1051
3502
                del self._annotate_children[node]
1068
3503
        # Generally we will want to read the records in reverse order, because
3429
        # Generally we will want to read the records in reverse order, because
1069
3504
        # we find the parent nodes after the children
3430
        # we find the parent nodes after the children
1070
3505
        records.reverse()
3431
        records.reverse()
1075
3506
        return records
3432
        return records, ann_keys
1076
3507
3433
1077
3508
    def _annotate_records(self, records):
3434
    def _get_needed_texts(self, key, pb=None):
1078
3509
        """Build the annotations for the listed records."""
3435
        # if True or len(self._vf._fallback_vfs) > 0:
1079
3436
        if len(self._vf._fallback_vfs) > 0:
1080
3437
            # If we have fallbacks, go to the generic path
1081
3438
            for v in annotate.Annotator._get_needed_texts(self, key, pb=pb):
1082
3439
                yield v
1083
3440
            return
1084
3441
        while True:
1085
3442
            try:
1086
3443
                records, ann_keys = self._get_build_graph(key)
1087
3444
                for idx, (sub_key, text, num_lines) in enumerate(
1088
3445
                                                self._extract_texts(records)):
1089
3446
                    if pb is not None:
1090
3447
                        pb.update('annotating', idx, len(records))
1091
3448
                    yield sub_key, text, num_lines
1092
3449
                for sub_key in ann_keys:
1093
3450
                    text = self._text_cache[sub_key]
1094
3451
                    num_lines = len(text) # bad assumption
1095
3452
                    yield sub_key, text, num_lines
1096
3453
                return
1097
3454
            except errors.RetryWithNewPacks, e:
1098
3455
                self._vf._access.reload_or_raise(e)
1099
3456
                # The cached build_details are no longer valid
1100
3457
                self._all_build_details.clear()
1101
3458
1102
3459
    def _cache_delta_blocks(self, key, compression_parent, delta, lines):
1103
3460
        parent_lines = self._text_cache[compression_parent]
1104
3461
        blocks = list(KnitContent.get_line_delta_blocks(delta, parent_lines, lines))
1105
3462
        self._matching_blocks[(key, compression_parent)] = blocks
1106
3463
1107
3464
    def _expand_record(self, key, parent_keys, compression_parent, record,
1108
3465
                       record_details):
1109
3466
        delta = None
1110
3467
        if compression_parent:
1111
3468
            if compression_parent not in self._content_objects:
1112
3469
                # Waiting for the parent
1113
3470
                self._pending_deltas.setdefault(compression_parent, []).append(
1114
3471
                    (key, parent_keys, record, record_details))
1115
3472
                return None
1116
3473
            # We have the basis parent, so expand the delta
1117
3474
            num = self._num_compression_children[compression_parent]
1118
3475
            num -= 1
1119
3476
            if num == 0:
1120
3477
                base_content = self._content_objects.pop(compression_parent)
1121
3478
                self._num_compression_children.pop(compression_parent)
1122
3479
            else:
1123
3480
                self._num_compression_children[compression_parent] = num
1124
3481
                base_content = self._content_objects[compression_parent]
1125
3482
            # It is tempting to want to copy_base_content=False for the last
1126
3483
            # child object. However, whenever noeol=False,
1127
3484
            # self._text_cache[parent_key] is content._lines. So mutating it
1128
3485
            # gives very bad results.
1129
3486
            # The alternative is to copy the lines into text cache, but then we
1130
3487
            # are copying anyway, so just do it here.
1131
3488
            content, delta = self._vf._factory.parse_record(
1132
3489
                key, record, record_details, base_content,
1133
3490
                copy_base_content=True)
1134
3491
        else:
1135
3492
            # Fulltext record
1136
3493
            content, _ = self._vf._factory.parse_record(
1137
3494
                key, record, record_details, None)
1138
3495
        if self._num_compression_children.get(key, 0) > 0:
1139
3496
            self._content_objects[key] = content
1140
3497
        lines = content.text()
1141
3498
        self._text_cache[key] = lines
1142
3499
        if delta is not None:
1143
3500
            self._cache_delta_blocks(key, compression_parent, delta, lines)
1144
3501
        return lines
1145
3502
1146
3503
    def _get_parent_annotations_and_matches(self, key, text, parent_key):
1147
3504
        """Get the list of annotations for the parent, and the matching lines.
1148
3505
1149
3506
        :param text: The opaque value given by _get_needed_texts
1150
3507
        :param parent_key: The key for the parent text
1151
3508
        :return: (parent_annotations, matching_blocks)
1152
3509
            parent_annotations is a list as long as the number of lines in
1153
3510
                parent
1154
3511
            matching_blocks is a list of (parent_idx, text_idx, len) tuples
1155
3512
                indicating which lines match between the two texts
1156
3513
        """
1157
3514
        block_key = (key, parent_key)
1158
3515
        if block_key in self._matching_blocks:
1159
3516
            blocks = self._matching_blocks.pop(block_key)
1160
3517
            parent_annotations = self._annotations_cache[parent_key]
1161
3518
            return parent_annotations, blocks
1162
3519
        return annotate.Annotator._get_parent_annotations_and_matches(self,
1163
3520
            key, text, parent_key)
1164
3521
1165
3522
    def _process_pending(self, key):
1166
3523
        """The content for 'key' was just processed.
1167
3524
1168
3525
        Determine if there is any more pending work to be processed.
1169
3526
        """
1170
3527
        to_return = []
1171
3528
        if key in self._pending_deltas:
1172
3529
            compression_parent = key
1173
3530
            children = self._pending_deltas.pop(key)
1174
3531
            for child_key, parent_keys, record, record_details in children:
1175
3532
                lines = self._expand_record(child_key, parent_keys,
1176
3533
                                            compression_parent,
1177
3534
                                            record, record_details)
1178
3535
                if self._check_ready_for_annotations(child_key, parent_keys):
1179
3536
                    to_return.append(child_key)
1180
3537
        # Also check any children that are waiting for this parent to be
1181
3538
        # annotation ready
1182
3539
        if key in self._pending_annotation:
1183
3540
            children = self._pending_annotation.pop(key)
1184
3541
            to_return.extend([c for c, p_keys in children
1185
3542
                              if self._check_ready_for_annotations(c, p_keys)])
1186
3543
        return to_return
1187
3544
1188
3545
    def _check_ready_for_annotations(self, key, parent_keys):
1189
3546
        """return true if this text is ready to be yielded.
1190
3547
1191
3548
        Otherwise, this will return False, and queue the text into
1192
3549
        self._pending_annotation
1193
3550
        """
1194
3551
        for parent_key in parent_keys:
1195
3552
            if parent_key not in self._annotations_cache:
1196
3553
                # still waiting on at least one parent text, so queue it up
1197
3554
                # Note that if there are multiple parents, we need to wait
1198
3555
                # for all of them.
1199
3556
                self._pending_annotation.setdefault(parent_key,
1200
3557
                    []).append((key, parent_keys))
1201
3558
                return False
1202
3559
        return True
1203
3560
1204
3561
    def _extract_texts(self, records):
1205
3562
        """Extract the various texts needed based on records"""
1206
3510
        # We iterate in the order read, rather than a strict order requested
3563
        # We iterate in the order read, rather than a strict order requested
1207
3511
        # However, process what we can, and put off to the side things that
3564
        # However, process what we can, and put off to the side things that
1208
3512
        # still need parents, cleaning them up when those parents are
3565
        # still need parents, cleaning them up when those parents are
1209
3513
        # processed.
3566
        # processed.
1213
3514
        for (rev_id, record,
3567
        # Basic data flow:
1214
3515
             digest) in self._knit._read_records_iter(records):
3568
        #   1) As 'records' are read, see if we can expand these records into
1215
3516
            if rev_id in self._annotated_lines:
3569
        #      Content objects (and thus lines)
1216
3570
        #   2) If a given line-delta is waiting on its compression parent, it
1217
3571
        #      gets queued up into self._pending_deltas, otherwise we expand
1218
3572
        #      it, and put it into self._text_cache and self._content_objects
1219
3573
        #   3) If we expanded the text, we will then check to see if all
1220
3574
        #      parents have also been processed. If so, this text gets yielded,
1221
3575
        #      else this record gets set aside into pending_annotation
1222
3576
        #   4) Further, if we expanded the text in (2), we will then check to
1223
3577
        #      see if there are any children in self._pending_deltas waiting to
1224
3578
        #      also be processed. If so, we go back to (2) for those
1225
3579
        #   5) Further again, if we yielded the text, we can then check if that
1226
3580
        #      'unlocks' any of the texts in pending_annotations, which should
1227
3581
        #      then get yielded as well
1228
3582
        # Note that both steps 4 and 5 are 'recursive' in that unlocking one
1229
3583
        # compression child could unlock yet another, and yielding a fulltext
1230
3584
        # will also 'unlock' the children that are waiting on that annotation.
1231
3585
        # (Though also, unlocking 1 parent's fulltext, does not unlock a child
1232
3586
        # if other parents are also waiting.)
1233
3587
        # We want to yield content before expanding child content objects, so
1234
3588
        # that we know when we can re-use the content lines, and the annotation
1235
3589
        # code can know when it can stop caching fulltexts, as well.
1236
3590
1237
3591
        # Children that are missing their compression parent
1238
3592
        pending_deltas = {}
1239
3593
        for (key, record, digest) in self._vf._read_records_iter(records):
1240
3594
            # ghosts?
1241
3595
            details = self._all_build_details[key]
1242
3596
            (_, compression_parent, parent_keys, record_details) = details
1243
3597
            lines = self._expand_record(key, parent_keys, compression_parent,
1244
3598
                                        record, record_details)
1245
3599
            if lines is None:
1246
3600
                # Pending delta should be queued up
1247
3517
                continue
3601
                continue
1375
3518
            parent_ids = self._revision_id_graph[rev_id]
3602
            # At this point, we may be able to yield this content, if all
1376
3519
            parent_ids = [p for p in parent_ids if p not in self._ghosts]
3603
            # parents are also finished
1377
3520
            details = self._all_build_details[rev_id]
3604
            yield_this_text = self._check_ready_for_annotations(key,
1378
3521
            (index_memo, compression_parent, parents,
3605
                                                                parent_keys)
1379
3522
             record_details) = details
3606
            if yield_this_text:
1380
3523
            nodes_to_annotate = []
3607
                # All parents present
1381
3524
            # TODO: Remove the punning between compression parents, and
3608
                yield key, lines, len(lines)
1382
3525
            #       parent_ids, we should be able to do this without assuming
3609
            to_process = self._process_pending(key)
1383
3526
            #       the build order
3610
            while to_process:
1384
3527
            if len(parent_ids) == 0:
3611
                this_process = to_process
1385
3528
                # There are no parents for this node, so just add it
3612
                to_process = []
1386
3529
                # TODO: This probably needs to be decoupled
3613
                for key in this_process:
1387
3530
                fulltext_content, delta = self._knit._factory.parse_record(
3614
                    lines = self._text_cache[key]
1388
3531
                    rev_id, record, record_details, None)
3615
                    yield key, lines, len(lines)
1389
3532
                fulltext = self._add_fulltext_content(rev_id, fulltext_content)
3616
                    to_process.extend(self._process_pending(key))
1263
3533
                nodes_to_annotate.extend(self._add_annotation(rev_id, fulltext,
1264
3534
                    parent_ids, left_matching_blocks=None))
1265
3535
            else:
1266
3536
                child = (rev_id, parent_ids, record)
1267
3537
                # Check if all the parents are present
1268
3538
                self._check_parents(child, nodes_to_annotate)
1269
3539
            while nodes_to_annotate:
1270
3540
                # Should we use a queue here instead of a stack?
1271
3541
                (rev_id, parent_ids, record) = nodes_to_annotate.pop()
1272
3542
                (index_memo, compression_parent, parents,
1273
3543
                 record_details) = self._all_build_details[rev_id]
1274
3544
                blocks = None
1275
3545
                if compression_parent is not None:
1276
3546
                    comp_children = self._compression_children[compression_parent]
1277
3547
                    if rev_id not in comp_children:
1278
3548
                        raise AssertionError("%r not in compression children %r"
1279
3549
                            % (rev_id, comp_children))
1280
3550
                    # If there is only 1 child, it is safe to reuse this
1281
3551
                    # content
1282
3552
                    reuse_content = (len(comp_children) == 1
1283
3553
                        and compression_parent not in
1284
3554
                            self._nodes_to_keep_annotations)
1285
3555
                    if reuse_content:
1286
3556
                        # Remove it from the cache since it will be changing
1287
3557
                        parent_fulltext_content = self._fulltext_contents.pop(compression_parent)
1288
3558
                        # Make sure to copy the fulltext since it might be
1289
3559
                        # modified
1290
3560
                        parent_fulltext = list(parent_fulltext_content.text())
1291
3561
                    else:
1292
3562
                        parent_fulltext_content = self._fulltext_contents[compression_parent]
1293
3563
                        parent_fulltext = parent_fulltext_content.text()
1294
3564
                    comp_children.remove(rev_id)
1295
3565
                    fulltext_content, delta = self._knit._factory.parse_record(
1296
3566
                        rev_id, record, record_details,
1297
3567
                        parent_fulltext_content,
1298
3568
                        copy_base_content=(not reuse_content))
1299
3569
                    fulltext = self._add_fulltext_content(rev_id,
1300
3570
                                                          fulltext_content)
1301
3571
                    if compression_parent == parent_ids[0]:
1302
3572
                        # the compression_parent is the left parent, so we can
1303
3573
                        # re-use the delta
1304
3574
                        blocks = KnitContent.get_line_delta_blocks(delta,
1305
3575
                                parent_fulltext, fulltext)
1306
3576
                else:
1307
3577
                    fulltext_content = self._knit._factory.parse_fulltext(
1308
3578
                        record, rev_id)
1309
3579
                    fulltext = self._add_fulltext_content(rev_id,
1310
3580
                        fulltext_content)
1311
3581
                nodes_to_annotate.extend(
1312
3582
                    self._add_annotation(rev_id, fulltext, parent_ids,
1313
3583
                                     left_matching_blocks=blocks))
1314
3584
1315
3585
    def _get_heads_provider(self):
1316
3586
        """Create a heads provider for resolving ancestry issues."""
1317
3587
        if self._heads_provider is not None:
1318
3588
            return self._heads_provider
1319
3589
        self._heads_provider = _mod_graph.KnownGraph(self._revision_id_graph)
1320
3590
        return self._heads_provider
1321
3591
1322
3592
    def annotate(self, key):
1323
3593
        """Return the annotated fulltext at the given key.
1324
3594
1325
3595
        :param key: The key to annotate.
1326
3596
        """
1327
3597
        if len(self._knit._fallback_vfs) > 0:
1328
3598
            # stacked knits can't use the fast path at present.
1329
3599
            return self._simple_annotate(key)
1330
3600
        while True:
1331
3601
            try:
1332
3602
                records = self._get_build_graph(key)
1333
3603
                if key in self._ghosts:
1334
3604
                    raise errors.RevisionNotPresent(key, self._knit)
1335
3605
                self._annotate_records(records)
1336
3606
                return self._annotated_lines[key]
1337
3607
            except errors.RetryWithNewPacks, e:
1338
3608
                self._knit._access.reload_or_raise(e)
1339
3609
                # The cached build_details are no longer valid
1340
3610
                self._all_build_details.clear()
1341
3611
1342
3612
    def _simple_annotate(self, key):
1343
3613
        """Return annotated fulltext, rediffing from the full texts.
1344
3614
1345
3615
        This is slow but makes no assumptions about the repository
1346
3616
        being able to produce line deltas.
1347
3617
        """
1348
3618
        # TODO: this code generates a parent maps of present ancestors; it
1349
3619
        #       could be split out into a separate method
1350
3620
        #       -- mbp and robertc 20080704
1351
3621
        graph = _mod_graph.Graph(self._knit)
1352
3622
        parent_map = dict((k, v) for k, v in graph.iter_ancestry([key])
1353
3623
                          if v is not None)
1354
3624
        if not parent_map:
1355
3625
            raise errors.RevisionNotPresent(key, self)
1356
3626
        keys = parent_map.keys()
1357
3627
        heads_provider = _mod_graph.KnownGraph(parent_map)
1358
3628
        parent_cache = {}
1359
3629
        reannotate = annotate.reannotate
1360
3630
        for record in self._knit.get_record_stream(keys, 'topological', True):
1361
3631
            key = record.key
1362
3632
            fulltext = osutils.chunks_to_lines(record.get_bytes_as('chunked'))
1363
3633
            parents = parent_map[key]
1364
3634
            if parents is not None:
1365
3635
                parent_lines = [parent_cache[parent] for parent in parent_map[key]]
1366
3636
            else:
1367
3637
                parent_lines = []
1368
3638
            parent_cache[key] = list(
1369
3639
                reannotate(parent_lines, fulltext, key, None, heads_provider))
1370
3640
        try:
1371
3641
            return parent_cache[key]
1372
3642
        except KeyError, e:
1373
3643
            raise errors.RevisionNotPresent(key, self._knit)
1374
3644
1390
3645
3617
1391
3646
try:
3618
try:
1392
3647
    from bzrlib._knit_load_data_c import _load_data_c as _load_data
3619
    from bzrlib._knit_load_data_c import _load_data_c as _load_data
1393
3648
3620
1394
=== modified file 'bzrlib/revisiontree.py'
1395
--- bzrlib/revisiontree.py	2009-06-17 03:41:33 +0000
1396
+++ bzrlib/revisiontree.py	2009-07-08 23:35:27 +0000
1397
@@ -87,7 +87,8 @@
1398
87
                      default_revision=revision.CURRENT_REVISION):
87
                      default_revision=revision.CURRENT_REVISION):
1399
88
        """See Tree.annotate_iter"""
88
        """See Tree.annotate_iter"""
1400
89
        text_key = (file_id, self.inventory[file_id].revision)
89
        text_key = (file_id, self.inventory[file_id].revision)
1402
90
        annotations = self._repository.texts.annotate(text_key)
90
        annotator = self._repository.texts.get_annotator()
1403
91
        annotations = annotator.annotate_flat(text_key)
1404
91
        return [(key[-1], line) for key, line in annotations]
92
        return [(key[-1], line) for key, line in annotations]
1405
92
93
1406
93
    def get_file_size(self, file_id):
94
    def get_file_size(self, file_id):
1407
94
95
1408
=== modified file 'bzrlib/tests/__init__.py'
1409
--- bzrlib/tests/__init__.py	2009-07-02 11:37:38 +0000
1410
+++ bzrlib/tests/__init__.py	2009-07-08 23:35:28 +0000
1411
@@ -3344,6 +3344,7 @@
1412
3344
                   'bzrlib.tests.per_repository',
3344
                   'bzrlib.tests.per_repository',
1413
3345
                   'bzrlib.tests.per_repository_chk',
3345
                   'bzrlib.tests.per_repository_chk',
1414
3346
                   'bzrlib.tests.per_repository_reference',
3346
                   'bzrlib.tests.per_repository_reference',
1415
3347
                   'bzrlib.tests.test__annotator',
1416
3347
                   'bzrlib.tests.test__chk_map',
3348
                   'bzrlib.tests.test__chk_map',
1417
3348
                   'bzrlib.tests.test__dirstate_helpers',
3349
                   'bzrlib.tests.test__dirstate_helpers',
1418
3349
                   'bzrlib.tests.test__groupcompress',
3350
                   'bzrlib.tests.test__groupcompress',
1419
3350
3351
1420
=== added file 'bzrlib/tests/test__annotator.py'
1421
--- bzrlib/tests/test__annotator.py	1970-01-01 00:00:00 +0000
1422
+++ bzrlib/tests/test__annotator.py	2009-07-08 23:35:28 +0000
1423
@@ -0,0 +1,403 @@
1424
1
# Copyright (C) 2009 Canonical Ltd
1425
2
#
1426
3
# This program is free software; you can redistribute it and/or modify
1427
4
# it under the terms of the GNU General Public License as published by
1428
5
# the Free Software Foundation; either version 2 of the License, or
1429
6
# (at your option) any later version.
1430
7
#
1431
8
# This program is distributed in the hope that it will be useful,
1432
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1433
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1434
11
# GNU General Public License for more details.
1435
12
#
1436
13
# You should have received a copy of the GNU General Public License
1437
14
# along with this program; if not, write to the Free Software
1438
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1439
16
1440
17
"""Tests for Annotators."""
1441
18
1442
19
from bzrlib import (
1443
20
    annotate,
1444
21
    _annotator_py,
1445
22
    errors,
1446
23
    knit,
1447
24
    revision,
1448
25
    tests,
1449
26
    )
1450
27
1451
28
1452
29
def load_tests(standard_tests, module, loader):
1453
30
    """Parameterize tests for all versions of groupcompress."""
1454
31
    scenarios = [
1455
32
        ('python', {'module': _annotator_py}),
1456
33
    ]
1457
34
    suite = loader.suiteClass()
1458
35
    if CompiledAnnotator.available():
1459
36
        from bzrlib import _annotator_pyx
1460
37
        scenarios.append(('C', {'module': _annotator_pyx}))
1461
38
    else:
1462
39
        # the compiled module isn't available, so we add a failing test
1463
40
        class FailWithoutFeature(tests.TestCase):
1464
41
            def test_fail(self):
1465
42
                self.requireFeature(CompiledAnnotator)
1466
43
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
1467
44
    result = tests.multiply_tests(standard_tests, scenarios, suite)
1468
45
    return result
1469
46
1470
47
1471
48
class _CompiledAnnotator(tests.Feature):
1472
49
1473
50
    def _probe(self):
1474
51
        try:
1475
52
            import bzrlib._annotator_pyx
1476
53
        except ImportError:
1477
54
            return False
1478
55
        return True
1479
56
1480
57
    def feature_name(self):
1481
58
        return 'bzrlib._annotator_pyx'
1482
59
1483
60
CompiledAnnotator = _CompiledAnnotator()
1484
61
1485
62
1486
63
class TestAnnotator(tests.TestCaseWithMemoryTransport):
1487
64
1488
65
    module = None # Set by load_tests
1489
66
1490
67
    fa_key = ('f-id', 'a-id')
1491
68
    fb_key = ('f-id', 'b-id')
1492
69
    fc_key = ('f-id', 'c-id')
1493
70
    fd_key = ('f-id', 'd-id')
1494
71
    fe_key = ('f-id', 'e-id')
1495
72
    ff_key = ('f-id', 'f-id')
1496
73
1497
74
    def make_no_graph_texts(self):
1498
75
        factory = knit.make_pack_factory(False, False, 2)
1499
76
        self.vf = factory(self.get_transport())
1500
77
        self.ann = self.module.Annotator(self.vf)
1501
78
        self.vf.add_lines(self.fa_key, (), ['simple\n', 'content\n'])
1502
79
        self.vf.add_lines(self.fb_key, (), ['simple\n', 'new content\n'])
1503
80
1504
81
    def make_simple_text(self):
1505
82
        # TODO: all we really need is a VersionedFile instance, we'd like to
1506
83
        #       avoid creating all the intermediate stuff
1507
84
        factory = knit.make_pack_factory(True, True, 2)
1508
85
        self.vf = factory(self.get_transport())
1509
86
        # This assumes nothing special happens during __init__, which may be
1510
87
        # valid
1511
88
        self.ann = self.module.Annotator(self.vf)
1512
89
        #  A    'simple|content|'
1513
90
        #  |
1514
91
        #  B    'simple|new content|'
1515
92
        self.vf.add_lines(self.fa_key, [], ['simple\n', 'content\n'])
1516
93
        self.vf.add_lines(self.fb_key, [self.fa_key],
1517
94
                          ['simple\n', 'new content\n'])
1518
95
1519
96
    def make_merge_text(self):
1520
97
        self.make_simple_text()
1521
98
        #  A    'simple|content|'
1522
99
        #  |\
1523
100
        #  B |  'simple|new content|'
1524
101
        #  | |
1525
102
        #  | C  'simple|from c|content|'
1526
103
        #  |/
1527
104
        #  D    'simple|from c|new content|introduced in merge|'
1528
105
        self.vf.add_lines(self.fc_key, [self.fa_key],
1529
106
                          ['simple\n', 'from c\n', 'content\n'])
1530
107
        self.vf.add_lines(self.fd_key, [self.fb_key, self.fc_key],
1531
108
                          ['simple\n', 'from c\n', 'new content\n',
1532
109
                           'introduced in merge\n'])
1533
110
1534
111
    def make_common_merge_text(self):
1535
112
        """Both sides of the merge will have introduced a line."""
1536
113
        self.make_simple_text()
1537
114
        #  A    'simple|content|'
1538
115
        #  |\
1539
116
        #  B |  'simple|new content|'
1540
117
        #  | |
1541
118
        #  | C  'simple|new content|'
1542
119
        #  |/
1543
120
        #  D    'simple|new content|'
1544
121
        self.vf.add_lines(self.fc_key, [self.fa_key],
1545
122
                          ['simple\n', 'new content\n'])
1546
123
        self.vf.add_lines(self.fd_key, [self.fb_key, self.fc_key],
1547
124
                          ['simple\n', 'new content\n'])
1548
125
1549
126
    def make_many_way_common_merge_text(self):
1550
127
        self.make_simple_text()
1551
128
        #  A-.    'simple|content|'
1552
129
        #  |\ \
1553
130
        #  B | |  'simple|new content|'
1554
131
        #  | | |
1555
132
        #  | C |  'simple|new content|'
1556
133
        #  |/  |
1557
134
        #  D   |  'simple|new content|'
1558
135
        #  |   |
1559
136
        #  |   E  'simple|new content|'
1560
137
        #  |  /
1561
138
        #  F-'    'simple|new content|'
1562
139
        self.vf.add_lines(self.fc_key, [self.fa_key],
1563
140
                          ['simple\n', 'new content\n'])
1564
141
        self.vf.add_lines(self.fd_key, [self.fb_key, self.fc_key],
1565
142
                          ['simple\n', 'new content\n'])
1566
143
        self.vf.add_lines(self.fe_key, [self.fa_key],
1567
144
                          ['simple\n', 'new content\n'])
1568
145
        self.vf.add_lines(self.ff_key, [self.fd_key, self.fe_key],
1569
146
                          ['simple\n', 'new content\n'])
1570
147
1571
148
    def make_merge_and_restored_text(self):
1572
149
        self.make_simple_text()
1573
150
        #  A    'simple|content|'
1574
151
        #  |\
1575
152
        #  B |  'simple|new content|'
1576
153
        #  | |
1577
154
        #  C |  'simple|content|' # reverted to A
1578
155
        #   \|
1579
156
        #    D  'simple|content|'
1580
157
        # c reverts back to 'a' for the new content line
1581
158
        self.vf.add_lines(self.fc_key, [self.fb_key],
1582
159
                          ['simple\n', 'content\n'])
1583
160
        # d merges 'a' and 'c', to find both claim last modified
1584
161
        self.vf.add_lines(self.fd_key, [self.fa_key, self.fc_key],
1585
162
                          ['simple\n', 'content\n'])
1586
163
1587
164
    def assertAnnotateEqual(self, expected_annotation, key, exp_text=None):
1588
165
        annotation, lines = self.ann.annotate(key)
1589
166
        self.assertEqual(expected_annotation, annotation)
1590
167
        if exp_text is None:
1591
168
            record = self.vf.get_record_stream([key], 'unordered', True).next()
1592
169
            exp_text = record.get_bytes_as('fulltext')
1593
170
        self.assertEqualDiff(exp_text, ''.join(lines))
1594
171
1595
172
    def test_annotate_missing(self):
1596
173
        self.make_simple_text()
1597
174
        self.assertRaises(errors.RevisionNotPresent,
1598
175
                          self.ann.annotate, ('not', 'present'))
1599
176
1600
177
    def test_annotate_simple(self):
1601
178
        self.make_simple_text()
1602
179
        self.assertAnnotateEqual([(self.fa_key,)]*2, self.fa_key)
1603
180
        self.assertAnnotateEqual([(self.fa_key,), (self.fb_key,)], self.fb_key)
1604
181
1605
182
    def test_annotate_merge_text(self):
1606
183
        self.make_merge_text()
1607
184
        self.assertAnnotateEqual([(self.fa_key,), (self.fc_key,),
1608
185
                                  (self.fb_key,), (self.fd_key,)],
1609
186
                                 self.fd_key)
1610
187
1611
188
    def test_annotate_common_merge_text(self):
1612
189
        self.make_common_merge_text()
1613
190
        self.assertAnnotateEqual([(self.fa_key,), (self.fb_key, self.fc_key)],
1614
191
                                 self.fd_key)
1615
192
1616
193
    def test_annotate_many_way_common_merge_text(self):
1617
194
        self.make_many_way_common_merge_text()
1618
195
        self.assertAnnotateEqual([(self.fa_key,),
1619
196
                                  (self.fb_key, self.fc_key, self.fe_key)],
1620
197
                                 self.ff_key)
1621
198
1622
199
    def test_annotate_merge_and_restored(self):
1623
200
        self.make_merge_and_restored_text()
1624
201
        self.assertAnnotateEqual([(self.fa_key,), (self.fa_key, self.fc_key)],
1625
202
                                 self.fd_key)
1626
203
1627
204
    def test_annotate_flat_simple(self):
1628
205
        self.make_simple_text()
1629
206
        self.assertEqual([(self.fa_key, 'simple\n'),
1630
207
                          (self.fa_key, 'content\n'),
1631
208
                         ], self.ann.annotate_flat(self.fa_key))
1632
209
        self.assertEqual([(self.fa_key, 'simple\n'),
1633
210
                          (self.fb_key, 'new content\n'),
1634
211
                         ], self.ann.annotate_flat(self.fb_key))
1635
212
1636
213
    def test_annotate_flat_merge_and_restored_text(self):
1637
214
        self.make_merge_and_restored_text()
1638
215
        # fc is a simple dominator of fa
1639
216
        self.assertEqual([(self.fa_key, 'simple\n'),
1640
217
                          (self.fc_key, 'content\n'),
1641
218
                         ], self.ann.annotate_flat(self.fd_key))
1642
219
1643
220
    def test_annotate_common_merge_text(self):
1644
221
        self.make_common_merge_text()
1645
222
        # there is no common point, so we just pick the lexicographical lowest
1646
223
        # and 'b-id' comes before 'c-id'
1647
224
        self.assertEqual([(self.fa_key, 'simple\n'),
1648
225
                          (self.fb_key, 'new content\n'),
1649
226
                         ], self.ann.annotate_flat(self.fd_key))
1650
227
1651
228
    def test_annotate_many_way_common_merge_text(self):
1652
229
        self.make_many_way_common_merge_text()
1653
230
        self.assertEqual([(self.fa_key, 'simple\n'),
1654
231
                         (self.fb_key, 'new content\n')],
1655
232
                         self.ann.annotate_flat(self.ff_key))
1656
233
1657
234
    def test_annotate_flat_respects_break_ann_tie(self):
1658
235
        tiebreaker = annotate._break_annotation_tie
1659
236
        try:
1660
237
            calls = []
1661
238
            def custom_tiebreaker(annotated_lines):
1662
239
                self.assertEqual(2, len(annotated_lines))
1663
240
                left = annotated_lines[0]
1664
241
                self.assertEqual(2, len(left))
1665
242
                self.assertEqual('new content\n', left[1])
1666
243
                right = annotated_lines[1]
1667
244
                self.assertEqual(2, len(right))
1668
245
                self.assertEqual('new content\n', right[1])
1669
246
                calls.append((left[0], right[0]))
1670
247
                # Our custom tiebreaker takes the *largest* value, rather than
1671
248
                # the *smallest* value
1672
249
                if left[0] < right[0]:
1673
250
                    return right
1674
251
                else:
1675
252
                    return left
1676
253
            annotate._break_annotation_tie = custom_tiebreaker
1677
254
            self.make_many_way_common_merge_text()
1678
255
            self.assertEqual([(self.fa_key, 'simple\n'),
1679
256
                             (self.fe_key, 'new content\n')],
1680
257
                             self.ann.annotate_flat(self.ff_key))
1681
258
            self.assertEqual([(self.fe_key, self.fc_key),
1682
259
                              (self.fe_key, self.fb_key)], calls)
1683
260
        finally:
1684
261
            annotate._break_annotation_tie = tiebreaker
1685
262
1686
263
1687
264
    def test_needed_keys_simple(self):
1688
265
        self.make_simple_text()
1689
266
        keys, ann_keys = self.ann._get_needed_keys(self.fb_key)
1690
267
        self.assertEqual([self.fa_key, self.fb_key], sorted(keys))
1691
268
        self.assertEqual({self.fa_key: 1, self.fb_key: 1},
1692
269
                         self.ann._num_needed_children)
1693
270
        self.assertEqual(set(), ann_keys)
1694
271
1695
272
    def test_needed_keys_many(self):
1696
273
        self.make_many_way_common_merge_text()
1697
274
        keys, ann_keys = self.ann._get_needed_keys(self.ff_key)
1698
275
        self.assertEqual([self.fa_key, self.fb_key, self.fc_key,
1699
276
                          self.fd_key, self.fe_key, self.ff_key,
1700
277
                         ], sorted(keys))
1701
278
        self.assertEqual({self.fa_key: 3,
1702
279
                          self.fb_key: 1,
1703
280
                          self.fc_key: 1,
1704
281
                          self.fd_key: 1,
1705
282
                          self.fe_key: 1,
1706
283
                          self.ff_key: 1,
1707
284
                         }, self.ann._num_needed_children)
1708
285
        self.assertEqual(set(), ann_keys)
1709
286
1710
287
    def test_needed_keys_with_special_text(self):
1711
288
        self.make_many_way_common_merge_text()
1712
289
        spec_key = ('f-id', revision.CURRENT_REVISION)
1713
290
        spec_text = 'simple\nnew content\nlocally modified\n'
1714
291
        self.ann.add_special_text(spec_key, [self.fd_key, self.fe_key],
1715
292
                                  spec_text)
1716
293
        keys, ann_keys = self.ann._get_needed_keys(spec_key)
1717
294
        self.assertEqual([self.fa_key, self.fb_key, self.fc_key,
1718
295
                          self.fd_key, self.fe_key,
1719
296
                         ], sorted(keys))
1720
297
        self.assertEqual([spec_key], sorted(ann_keys))
1721
298
1722
299
    def test_needed_keys_with_parent_texts(self):
1723
300
        self.make_many_way_common_merge_text()
1724
301
        # If 'D' and 'E' are already annotated, we don't need to extract all
1725
302
        # the texts
1726
303
        #  D   |  'simple|new content|'
1727
304
        #  |   |
1728
305
        #  |   E  'simple|new content|'
1729
306
        #  |  /
1730
307
        #  F-'    'simple|new content|'
1731
308
        self.ann._parent_map[self.fd_key] = (self.fb_key, self.fc_key)
1732
309
        self.ann._text_cache[self.fd_key] = ['simple\n', 'new content\n']
1733
310
        self.ann._annotations_cache[self.fd_key] = [
1734
311
            (self.fa_key,),
1735
312
            (self.fb_key, self.fc_key),
1736
313
            ]
1737
314
        self.ann._parent_map[self.fe_key] = (self.fa_key,)
1738
315
        self.ann._text_cache[self.fe_key] = ['simple\n', 'new content\n']
1739
316
        self.ann._annotations_cache[self.fe_key] = [
1740
317
            (self.fa_key,),
1741
318
            (self.fe_key,),
1742
319
            ]
1743
320
        keys, ann_keys = self.ann._get_needed_keys(self.ff_key)
1744
321
        self.assertEqual([self.ff_key], sorted(keys))
1745
322
        self.assertEqual({self.fd_key: 1,
1746
323
                          self.fe_key: 1,
1747
324
                          self.ff_key: 1,
1748
325
                         }, self.ann._num_needed_children)
1749
326
        self.assertEqual([], sorted(ann_keys))
1750
327
1751
328
    def test_record_annotation_removes_texts(self):
1752
329
        self.make_many_way_common_merge_text()
1753
330
        # Populate the caches
1754
331
        for x in self.ann._get_needed_texts(self.ff_key):
1755
332
            continue
1756
333
        self.assertEqual({self.fa_key: 3,
1757
334
                          self.fb_key: 1,
1758
335
                          self.fc_key: 1,
1759
336
                          self.fd_key: 1,
1760
337
                          self.fe_key: 1,
1761
338
                          self.ff_key: 1,
1762
339
                         }, self.ann._num_needed_children)
1763
340
        self.assertEqual([self.fa_key, self.fb_key, self.fc_key,
1764
341
                          self.fd_key, self.fe_key, self.ff_key,
1765
342
                         ], sorted(self.ann._text_cache.keys()))
1766
343
        self.ann._record_annotation(self.fa_key, [], [])
1767
344
        self.ann._record_annotation(self.fb_key, [self.fa_key], [])
1768
345
        self.assertEqual({self.fa_key: 2,
1769
346
                          self.fb_key: 1,
1770
347
                          self.fc_key: 1,
1771
348
                          self.fd_key: 1,
1772
349
                          self.fe_key: 1,
1773
350
                          self.ff_key: 1,
1774
351
                         }, self.ann._num_needed_children)
1775
352
        self.assertTrue(self.fa_key in self.ann._text_cache)
1776
353
        self.assertTrue(self.fa_key in self.ann._annotations_cache)
1777
354
        self.ann._record_annotation(self.fc_key, [self.fa_key], [])
1778
355
        self.ann._record_annotation(self.fd_key, [self.fb_key, self.fc_key], [])
1779
356
        self.assertEqual({self.fa_key: 1,
1780
357
                          self.fb_key: 0,
1781
358
                          self.fc_key: 0,
1782
359
                          self.fd_key: 1,
1783
360
                          self.fe_key: 1,
1784
361
                          self.ff_key: 1,
1785
362
                         }, self.ann._num_needed_children)
1786
363
        self.assertTrue(self.fa_key in self.ann._text_cache)
1787
364
        self.assertTrue(self.fa_key in self.ann._annotations_cache)
1788
365
        self.assertFalse(self.fb_key in self.ann._text_cache)
1789
366
        self.assertFalse(self.fb_key in self.ann._annotations_cache)
1790
367
        self.assertFalse(self.fc_key in self.ann._text_cache)
1791
368
        self.assertFalse(self.fc_key in self.ann._annotations_cache)
1792
369
1793
370
    def test_annotate_special_text(self):
1794
371
        # Things like WT and PreviewTree want to annotate an arbitrary text
1795
372
        # ('current:') so we need a way to add that to the group of files to be
1796
373
        # annotated.
1797
374
        self.make_many_way_common_merge_text()
1798
375
        #  A-.    'simple|content|'
1799
376
        #  |\ \
1800
377
        #  B | |  'simple|new content|'
1801
378
        #  | | |
1802
379
        #  | C |  'simple|new content|'
1803
380
        #  |/  |
1804
381
        #  D   |  'simple|new content|'
1805
382
        #  |   |
1806
383
        #  |   E  'simple|new content|'
1807
384
        #  |  /
1808
385
        #  SPEC   'simple|new content|locally modified|'
1809
386
        spec_key = ('f-id', revision.CURRENT_REVISION)
1810
387
        spec_text = 'simple\nnew content\nlocally modified\n'
1811
388
        self.ann.add_special_text(spec_key, [self.fd_key, self.fe_key],
1812
389
                                  spec_text)
1813
390
        self.assertAnnotateEqual([(self.fa_key,),
1814
391
                                  (self.fb_key, self.fc_key, self.fe_key),
1815
392
                                  (spec_key,),
1816
393
                                 ], spec_key,
1817
394
                                 exp_text=spec_text)
1818
395
1819
396
    def test_no_graph(self):
1820
397
        self.make_no_graph_texts()
1821
398
        self.assertAnnotateEqual([(self.fa_key,),
1822
399
                                  (self.fa_key,),
1823
400
                                 ], self.fa_key)
1824
401
        self.assertAnnotateEqual([(self.fb_key,),
1825
402
                                  (self.fb_key,),
1826
403
                                 ], self.fb_key)
1827
0
404
1828
=== modified file 'bzrlib/tests/test__known_graph.py'
1829
--- bzrlib/tests/test__known_graph.py	2009-06-18 19:45:24 +0000
1830
+++ bzrlib/tests/test__known_graph.py	2009-07-08 23:35:28 +0000
1831
@@ -14,7 +14,7 @@
1832
14
# along with this program; if not, write to the Free Software
14
# along with this program; if not, write to the Free Software
1833
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1834
16
16
1836
17
"""Tests for the python and pyrex extensions of groupcompress"""
17
"""Tests for the python and pyrex extensions of KnownGraph"""
1837
18
18
1838
19
from bzrlib import (
19
from bzrlib import (
1839
20
    errors,
20
    errors,
1840
@@ -63,6 +63,16 @@
1841
63
CompiledKnownGraphFeature = _CompiledKnownGraphFeature()
63
CompiledKnownGraphFeature = _CompiledKnownGraphFeature()
1842
64
64
1843
65
65
1844
66
#  a
1845
67
#  |\
1846
68
#  b |
1847
69
#  | |
1848
70
#  c |
1849
71
#   \|
1850
72
#    d
1851
73
alt_merge = {'a': [], 'b': ['a'], 'c': ['b'], 'd': ['a', 'c']}
1852
74
1853
75
1854
66
class TestKnownGraph(tests.TestCase):
76
class TestKnownGraph(tests.TestCase):
1855
67
77
1856
68
    module = None # Set by load_tests
78
    module = None # Set by load_tests
1857
@@ -203,6 +213,10 @@
1858
203
        self.assertEqual(set(['w', 'q']), graph.heads(['w', 's', 'q']))
213
        self.assertEqual(set(['w', 'q']), graph.heads(['w', 's', 'q']))
1859
204
        self.assertEqual(set(['z']), graph.heads(['s', 'z']))
214
        self.assertEqual(set(['z']), graph.heads(['s', 'z']))
1860
205
215
1861
216
    def test_heads_alt_merge(self):
1862
217
        graph = self.make_known_graph(alt_merge)
1863
218
        self.assertEqual(set(['c']), graph.heads(['a', 'c']))
1864
219
1865
206
    def test_heads_with_ghost(self):
220
    def test_heads_with_ghost(self):
1866
207
        graph = self.make_known_graph(test_graph.with_ghost)
221
        graph = self.make_known_graph(test_graph.with_ghost)
1867
208
        self.assertEqual(set(['e', 'g']), graph.heads(['e', 'g']))
222
        self.assertEqual(set(['e', 'g']), graph.heads(['e', 'g']))
1868
209
223
1869
=== modified file 'bzrlib/tests/test_annotate.py'
1870
--- bzrlib/tests/test_annotate.py	2009-03-23 14:59:43 +0000
1871
+++ bzrlib/tests/test_annotate.py	2009-07-08 23:35:28 +0000
1872
@@ -176,38 +176,23 @@
1873
176
         |
176
         |
1874
177
        rev-3
177
        rev-3
1875
178
        """
178
        """
1908
179
179
        builder = self.make_branch_builder('branch')
1909
180
        tree1 = self.make_branch_and_tree('tree1')
180
        builder.start_series()
1910
181
        self.build_tree_contents([('tree1/a', 'first\n')])
181
        self.addCleanup(builder.finish_series)
1911
182
        tree1.add(['a'], ['a-id'])
182
        builder.build_snapshot('rev-1', None, [
1912
183
        tree1.commit('a', rev_id='rev-1',
183
            ('add', ('', 'root-id', 'directory', None)),
1913
184
                     committer="joe@foo.com",
184
            ('add', ('a', 'a-id', 'file', 'first\n')),
1914
185
                     timestamp=1166046000.00, timezone=0)
185
            ], timestamp=1166046000.00, committer="joe@foo.com")
1915
186
186
        builder.build_snapshot('rev-2', ['rev-1'], [
1916
187
        tree2 = tree1.bzrdir.sprout('tree2').open_workingtree()
187
            ('modify', ('a-id', 'first\nsecond\n')),
1917
188
188
            ], timestamp=1166046001.00, committer="joe@foo.com")
1918
189
        self.build_tree_contents([('tree1/a', 'first\nsecond\n')])
189
        builder.build_snapshot('rev-1_1_1', ['rev-1'], [
1919
190
        tree1.commit('b', rev_id='rev-2',
190
            ('modify', ('a-id', 'first\nthird\n')),
1920
191
                     committer='joe@foo.com',
191
            ], timestamp=1166046002.00, committer="barry@foo.com")
1921
192
                     timestamp=1166046001.00, timezone=0)
192
        builder.build_snapshot('rev-3', ['rev-2', 'rev-1_1_1'], [
1922
193
193
            ('modify', ('a-id', 'first\nsecond\nthird\n')),
1923
194
        self.build_tree_contents([('tree2/a', 'first\nthird\n')])
194
            ], timestamp=1166046003.00, committer="sal@foo.com")
1924
195
        tree2.commit('c', rev_id='rev-1_1_1',
195
        return builder
1893
196
                     committer="barry@foo.com",
1894
197
                     timestamp=1166046002.00, timezone=0)
1895
198
1896
199
        num_conflicts = tree1.merge_from_branch(tree2.branch)
1897
200
        self.assertEqual(1, num_conflicts)
1898
201
1899
202
        self.build_tree_contents([('tree1/a',
1900
203
                                 'first\nsecond\nthird\n')])
1901
204
        tree1.set_conflicts(conflicts.ConflictList())
1902
205
        tree1.commit('merge 2', rev_id='rev-3',
1903
206
                     committer='sal@foo.com',
1904
207
                     timestamp=1166046003.00, timezone=0)
1905
208
        tree1.lock_read()
1906
209
        self.addCleanup(tree1.unlock)
1907
210
        return tree1, tree2
1925
211
196
1926
212
    def create_deeply_merged_trees(self):
197
    def create_deeply_merged_trees(self):
1927
213
        """Create some trees with a more complex merge history.
198
        """Create some trees with a more complex merge history.
1928
@@ -232,69 +217,51 @@
1929
232
         |
217
         |
1930
233
        rev-6
218
        rev-6
1931
234
        """
219
        """
1963
235
        tree1, tree2 = self.create_merged_trees()
220
        builder = self.create_merged_trees()
1964
236
        tree1.unlock()
221
        builder.build_snapshot('rev-1_1_2', ['rev-1_1_1'], [])
1965
237
222
        builder.build_snapshot('rev-4', ['rev-3', 'rev-1_1_2'], [])
1966
238
        tree3 = tree2.bzrdir.sprout('tree3').open_workingtree()
223
        builder.build_snapshot('rev-1_2_1', ['rev-1_1_1'], [
1967
239
224
            ('modify', ('a-id', 'first\nthird\nfourth\n')),
1968
240
        tree2.commit('noop', rev_id='rev-1_1_2')
225
            ], timestamp=1166046003.00, committer="jerry@foo.com")
1969
241
        self.assertEqual(0, tree1.merge_from_branch(tree2.branch))
226
        builder.build_snapshot('rev-1_2_2', ['rev-1_2_1'], [],
1970
242
        tree1.commit('noop merge', rev_id='rev-4')
227
            timestamp=1166046004.00, committer="jerry@foo.com")
1971
243
228
        builder.build_snapshot('rev-5', ['rev-4', 'rev-1_2_2'], [
1972
244
        self.build_tree_contents([('tree3/a', 'first\nthird\nfourth\n')])
229
            ('modify', ('a-id', 'first\nsecond\nthird\nfourth\n')),
1973
245
        tree3.commit('four', rev_id='rev-1_2_1',
230
            ], timestamp=1166046004.00, committer="jerry@foo.com")
1974
246
                     committer='jerry@foo.com',
231
        builder.build_snapshot('rev-1_3_1', ['rev-1_2_1'], [
1975
247
                     timestamp=1166046003.00, timezone=0)
232
            ('modify', ('a-id', 'first\nthird\nfourth\nfifth\nsixth\n')),
1976
248
233
            ], timestamp=1166046005.00, committer="george@foo.com")
1977
249
        tree4 = tree3.bzrdir.sprout('tree4').open_workingtree()
234
        builder.build_snapshot('rev-6', ['rev-5', 'rev-1_3_1'], [
1978
250
235
            ('modify', ('a-id',
1979
251
        tree3.commit('noop', rev_id='rev-1_2_2',
236
                        'first\nsecond\nthird\nfourth\nfifth\nsixth\n')),
1980
252
                     committer='jerry@foo.com',
237
            ])
1981
253
                     timestamp=1166046004.00, timezone=0)
238
        return builder
1951
254
        self.assertEqual(0, tree1.merge_from_branch(tree3.branch))
1952
255
        tree1.commit('merge four', rev_id='rev-5')
1953
256
1954
257
        self.build_tree_contents([('tree4/a',
1955
258
                                   'first\nthird\nfourth\nfifth\nsixth\n')])
1956
259
        tree4.commit('five and six', rev_id='rev-1_3_1',
1957
260
                     committer='george@foo.com',
1958
261
                     timestamp=1166046005.00, timezone=0)
1959
262
        self.assertEqual(0, tree1.merge_from_branch(tree4.branch))
1960
263
        tree1.commit('merge five and six', rev_id='rev-6')
1961
264
        tree1.lock_read()
1962
265
        return tree1
1982
266
239
1983
267
    def create_duplicate_lines_tree(self):
240
    def create_duplicate_lines_tree(self):
1985
268
        tree1 = self.make_branch_and_tree('tree1')
241
        builder = self.make_branch_builder('branch')
1986
242
        builder.start_series()
1987
243
        self.addCleanup(builder.finish_series)
1988
269
        base_text = ''.join(l for r, l in duplicate_base)
244
        base_text = ''.join(l for r, l in duplicate_base)
1989
270
        a_text = ''.join(l for r, l in duplicate_A)
245
        a_text = ''.join(l for r, l in duplicate_A)
1990
271
        b_text = ''.join(l for r, l in duplicate_B)
246
        b_text = ''.join(l for r, l in duplicate_B)
1991
272
        c_text = ''.join(l for r, l in duplicate_C)
247
        c_text = ''.join(l for r, l in duplicate_C)
1992
273
        d_text = ''.join(l for r, l in duplicate_D)
248
        d_text = ''.join(l for r, l in duplicate_D)
1993
274
        e_text = ''.join(l for r, l in duplicate_E)
249
        e_text = ''.join(l for r, l in duplicate_E)
2017
275
        self.build_tree_contents([('tree1/file', base_text)])
250
        builder.build_snapshot('rev-base', None, [
2018
276
        tree1.add(['file'], ['file-id'])
251
            ('add', ('', 'root-id', 'directory', None)),
2019
277
        tree1.commit('base', rev_id='rev-base')
252
            ('add', ('file', 'file-id', 'file', base_text)),
2020
278
        tree2 = tree1.bzrdir.sprout('tree2').open_workingtree()
253
            ])
2021
279
254
        builder.build_snapshot('rev-A', ['rev-base'], [
2022
280
        self.build_tree_contents([('tree1/file', a_text),
255
            ('modify', ('file-id', a_text))])
2023
281
                                  ('tree2/file', b_text)])
256
        builder.build_snapshot('rev-B', ['rev-base'], [
2024
282
        tree1.commit('A', rev_id='rev-A')
257
            ('modify', ('file-id', b_text))])
2025
283
        tree2.commit('B', rev_id='rev-B')
258
        builder.build_snapshot('rev-C', ['rev-A'], [
2026
284
259
            ('modify', ('file-id', c_text))])
2027
285
        tree2.merge_from_branch(tree1.branch)
260
        builder.build_snapshot('rev-D', ['rev-B', 'rev-A'], [
2028
286
        conflicts.resolve(tree2, None) # Resolve the conflicts
261
            ('modify', ('file-id', d_text))])
2029
287
        self.build_tree_contents([('tree2/file', d_text)])
262
        builder.build_snapshot('rev-E', ['rev-C', 'rev-D'], [
2030
288
        tree2.commit('D', rev_id='rev-D')
263
            ('modify', ('file-id', e_text))])
2031
289
264
        return builder
2009
290
        self.build_tree_contents([('tree1/file', c_text)])
2010
291
        tree1.commit('C', rev_id='rev-C')
2011
292
2012
293
        tree1.merge_from_branch(tree2.branch)
2013
294
        conflicts.resolve(tree1, None) # Resolve the conflicts
2014
295
        self.build_tree_contents([('tree1/file', e_text)])
2015
296
        tree1.commit('E', rev_id='rev-E')
2016
297
        return tree1
2032
298
265
2033
299
    def assertRepoAnnotate(self, expected, repo, file_id, revision_id):
266
    def assertRepoAnnotate(self, expected, repo, file_id, revision_id):
2034
300
        """Assert that the revision is properly annotated."""
267
        """Assert that the revision is properly annotated."""
2035
@@ -307,8 +274,8 @@
2036
307
274
2037
308
    def test_annotate_duplicate_lines(self):
275
    def test_annotate_duplicate_lines(self):
2038
309
        # XXX: Should this be a per_repository test?
276
        # XXX: Should this be a per_repository test?
2041
310
        tree1 = self.create_duplicate_lines_tree()
277
        builder = self.create_duplicate_lines_tree()
2042
311
        repo = tree1.branch.repository
278
        repo = builder.get_branch().repository
2043
312
        repo.lock_read()
279
        repo.lock_read()
2044
313
        self.addCleanup(repo.unlock)
280
        self.addCleanup(repo.unlock)
2045
314
        self.assertRepoAnnotate(duplicate_base, repo, 'file-id', 'rev-base')
281
        self.assertRepoAnnotate(duplicate_base, repo, 'file-id', 'rev-base')
2046
@@ -319,10 +286,10 @@
2047
319
        self.assertRepoAnnotate(duplicate_E, repo, 'file-id', 'rev-E')
286
        self.assertRepoAnnotate(duplicate_E, repo, 'file-id', 'rev-E')
2048
320
287
2049
321
    def test_annotate_shows_dotted_revnos(self):
288
    def test_annotate_shows_dotted_revnos(self):
2051
322
        tree1, tree2 = self.create_merged_trees()
289
        builder = self.create_merged_trees()
2052
323
290
2053
324
        sio = StringIO()
291
        sio = StringIO()
2055
325
        annotate.annotate_file(tree1.branch, 'rev-3', 'a-id',
292
        annotate.annotate_file(builder.get_branch(), 'rev-3', 'a-id',
2056
326
                               to_file=sio)
293
                               to_file=sio)
2057
327
        self.assertEqualDiff('1     joe@foo | first\n'
294
        self.assertEqualDiff('1     joe@foo | first\n'
2058
328
                             '2     joe@foo | second\n'
295
                             '2     joe@foo | second\n'
2059
@@ -331,10 +298,10 @@
2060
331
298
2061
332
    def test_annotate_limits_dotted_revnos(self):
299
    def test_annotate_limits_dotted_revnos(self):
2062
333
        """Annotate should limit dotted revnos to a depth of 12"""
300
        """Annotate should limit dotted revnos to a depth of 12"""
2064
334
        tree1 = self.create_deeply_merged_trees()
301
        builder = self.create_deeply_merged_trees()
2065
335
302
2066
336
        sio = StringIO()
303
        sio = StringIO()
2068
337
        annotate.annotate_file(tree1.branch, 'rev-6', 'a-id',
304
        annotate.annotate_file(builder.get_branch(), 'rev-6', 'a-id',
2069
338
                               to_file=sio, verbose=False, full=False)
305
                               to_file=sio, verbose=False, full=False)
2070
339
        self.assertEqualDiff('1     joe@foo | first\n'
306
        self.assertEqualDiff('1     joe@foo | first\n'
2071
340
                             '2     joe@foo | second\n'
307
                             '2     joe@foo | second\n'
2072
@@ -345,7 +312,7 @@
2073
345
                             sio.getvalue())
312
                             sio.getvalue())
2074
346
313
2075
347
        sio = StringIO()
314
        sio = StringIO()
2077
348
        annotate.annotate_file(tree1.branch, 'rev-6', 'a-id',
315
        annotate.annotate_file(builder.get_branch(), 'rev-6', 'a-id',
2078
349
                               to_file=sio, verbose=False, full=True)
316
                               to_file=sio, verbose=False, full=True)
2079
350
        self.assertEqualDiff('1     joe@foo | first\n'
317
        self.assertEqualDiff('1     joe@foo | first\n'
2080
351
                             '2     joe@foo | second\n'
318
                             '2     joe@foo | second\n'
2081
@@ -357,7 +324,7 @@
2082
357
324
2083
358
        # verbose=True shows everything, the full revno, user id, and date
325
        # verbose=True shows everything, the full revno, user id, and date
2084
359
        sio = StringIO()
326
        sio = StringIO()
2086
360
        annotate.annotate_file(tree1.branch, 'rev-6', 'a-id',
327
        annotate.annotate_file(builder.get_branch(), 'rev-6', 'a-id',
2087
361
                               to_file=sio, verbose=True, full=False)
328
                               to_file=sio, verbose=True, full=False)
2088
362
        self.assertEqualDiff('1     joe@foo.com    20061213 | first\n'
329
        self.assertEqualDiff('1     joe@foo.com    20061213 | first\n'
2089
363
                             '2     joe@foo.com    20061213 | second\n'
330
                             '2     joe@foo.com    20061213 | second\n'
2090
@@ -368,7 +335,7 @@
2091
368
                             sio.getvalue())
335
                             sio.getvalue())
2092
369
336
2093
370
        sio = StringIO()
337
        sio = StringIO()
2095
371
        annotate.annotate_file(tree1.branch, 'rev-6', 'a-id',
338
        annotate.annotate_file(builder.get_branch(), 'rev-6', 'a-id',
2096
372
                               to_file=sio, verbose=True, full=True)
339
                               to_file=sio, verbose=True, full=True)
2097
373
        self.assertEqualDiff('1     joe@foo.com    20061213 | first\n'
340
        self.assertEqualDiff('1     joe@foo.com    20061213 | first\n'
2098
374
                             '2     joe@foo.com    20061213 | second\n'
341
                             '2     joe@foo.com    20061213 | second\n'
2099
@@ -384,10 +351,10 @@
2100
384
        When annotating a non-mainline revision, the annotation should still
351
        When annotating a non-mainline revision, the annotation should still
2101
385
        use dotted revnos from the mainline.
352
        use dotted revnos from the mainline.
2102
386
        """
353
        """
2104
387
        tree1 = self.create_deeply_merged_trees()
354
        builder = self.create_deeply_merged_trees()
2105
388
355
2106
389
        sio = StringIO()
356
        sio = StringIO()
2108
390
        annotate.annotate_file(tree1.branch, 'rev-1_3_1', 'a-id',
357
        annotate.annotate_file(builder.get_branch(), 'rev-1_3_1', 'a-id',
2109
391
                               to_file=sio, verbose=False, full=False)
358
                               to_file=sio, verbose=False, full=False)
2110
392
        self.assertEqualDiff('1     joe@foo | first\n'
359
        self.assertEqualDiff('1     joe@foo | first\n'
2111
393
                             '1.1.1 barry@f | third\n'
360
                             '1.1.1 barry@f | third\n'
2112
@@ -397,10 +364,10 @@
2113
397
                             sio.getvalue())
364
                             sio.getvalue())
2114
398
365
2115
399
    def test_annotate_show_ids(self):
366
    def test_annotate_show_ids(self):
2117
400
        tree1 = self.create_deeply_merged_trees()
367
        builder = self.create_deeply_merged_trees()
2118
401
368
2119
402
        sio = StringIO()
369
        sio = StringIO()
2121
403
        annotate.annotate_file(tree1.branch, 'rev-6', 'a-id',
370
        annotate.annotate_file(builder.get_branch(), 'rev-6', 'a-id',
2122
404
                               to_file=sio, show_ids=True, full=False)
371
                               to_file=sio, show_ids=True, full=False)
2123
405
372
2124
406
        # It looks better with real revision ids :)
373
        # It looks better with real revision ids :)
2125
@@ -413,7 +380,7 @@
2126
413
                             sio.getvalue())
380
                             sio.getvalue())
2127
414
381
2128
415
        sio = StringIO()
382
        sio = StringIO()
2130
416
        annotate.annotate_file(tree1.branch, 'rev-6', 'a-id',
383
        annotate.annotate_file(builder.get_branch(), 'rev-6', 'a-id',
2131
417
                               to_file=sio, show_ids=True, full=True)
384
                               to_file=sio, show_ids=True, full=True)
2132
418
385
2133
419
        self.assertEqualDiff('    rev-1 | first\n'
386
        self.assertEqualDiff('    rev-1 | first\n'
2134
420
387
2135
=== modified file 'bzrlib/tests/test_knit.py'
2136
--- bzrlib/tests/test_knit.py	2009-06-16 13:57:14 +0000
2137
+++ bzrlib/tests/test_knit.py	2009-07-08 23:35:28 +0000
2138
@@ -366,16 +366,25 @@
2139
366
        :return: (versioned_file, reload_counter)
366
        :return: (versioned_file, reload_counter)
2140
367
            versioned_file  a KnitVersionedFiles using the packs for access
367
            versioned_file  a KnitVersionedFiles using the packs for access
2141
368
        """
368
        """
2149
369
        tree = self.make_branch_and_memory_tree('tree')
369
        builder = self.make_branch_builder('.')
2150
370
        tree.lock_write()
370
        builder.start_series()
2151
371
        self.addCleanup(tree.unlock)
371
        builder.build_snapshot('rev-1', None, [
2152
372
        tree.add([''], ['root-id'])
372
            ('add', ('', 'root-id', 'directory', None)),
2153
373
        tree.commit('one', rev_id='rev-1')
373
            ('add', ('file', 'file-id', 'file', 'content\nrev 1\n')),
2154
374
        tree.commit('two', rev_id='rev-2')
374
            ])
2155
375
        tree.commit('three', rev_id='rev-3')
375
        builder.build_snapshot('rev-2', ['rev-1'], [
2156
376
            ('modify', ('file-id', 'content\nrev 2\n')),
2157
377
            ])
2158
378
        builder.build_snapshot('rev-3', ['rev-2'], [
2159
379
            ('modify', ('file-id', 'content\nrev 3\n')),
2160
380
            ])
2161
381
        builder.finish_series()
2162
382
        b = builder.get_branch()
2163
383
        b.lock_write()
2164
384
        self.addCleanup(b.unlock)
2165
376
        # Pack these three revisions into another pack file, but don't remove
385
        # Pack these three revisions into another pack file, but don't remove
2166
377
        # the originals
386
        # the originals
2168
378
        repo = tree.branch.repository
387
        repo = b.repository
2169
379
        collection = repo._pack_collection
388
        collection = repo._pack_collection
2170
380
        collection.ensure_loaded()
389
        collection.ensure_loaded()
2171
381
        orig_packs = collection.packs
390
        orig_packs = collection.packs
2172
@@ -384,7 +393,7 @@
2173
384
        # forget about the new pack
393
        # forget about the new pack
2174
385
        collection.reset()
394
        collection.reset()
2175
386
        repo.refresh_data()
395
        repo.refresh_data()
2177
387
        vf = tree.branch.repository.revisions
396
        vf = repo.revisions
2178
388
        # Set up a reload() function that switches to using the new pack file
397
        # Set up a reload() function that switches to using the new pack file
2179
389
        new_index = new_pack.revision_index
398
        new_index = new_pack.revision_index
2180
390
        access_tuple = new_pack.access_tuple()
399
        access_tuple = new_pack.access_tuple()
2181
@@ -1313,6 +1322,168 @@
2182
1313
        return _KndxIndex(transport, mapper, lambda:None, allow_writes, lambda:True)
1322
        return _KndxIndex(transport, mapper, lambda:None, allow_writes, lambda:True)
2183
1314
1323
2184
1315
1324
2185
1325
class Test_KnitAnnotator(TestCaseWithMemoryTransport):
2186
1326
2187
1327
    def make_annotator(self):
2188
1328
        factory = knit.make_pack_factory(True, True, 1)
2189
1329
        vf = factory(self.get_transport())
2190
1330
        return knit._KnitAnnotator(vf)
2191
1331
2192
1332
    def test__expand_fulltext(self):
2193
1333
        ann = self.make_annotator()
2194
1334
        rev_key = ('rev-id',)
2195
1335
        ann._num_compression_children[rev_key] = 1
2196
1336
        res = ann._expand_record(rev_key, (('parent-id',),), None,
2197
1337
                           ['line1\n', 'line2\n'], ('fulltext', True))
2198
1338
        # The content object and text lines should be cached appropriately
2199
1339
        self.assertEqual(['line1\n', 'line2'], res)
2200
1340
        content_obj = ann._content_objects[rev_key]
2201
1341
        self.assertEqual(['line1\n', 'line2\n'], content_obj._lines)
2202
1342
        self.assertEqual(res, content_obj.text())
2203
1343
        self.assertEqual(res, ann._text_cache[rev_key])
2204
1344
2205
1345
    def test__expand_delta_comp_parent_not_available(self):
2206
1346
        # Parent isn't available yet, so we return nothing, but queue up this
2207
1347
        # node for later processing
2208
1348
        ann = self.make_annotator()
2209
1349
        rev_key = ('rev-id',)
2210
1350
        parent_key = ('parent-id',)
2211
1351
        record = ['0,1,1\n', 'new-line\n']
2212
1352
        details = ('line-delta', False)
2213
1353
        res = ann._expand_record(rev_key, (parent_key,), parent_key,
2214
1354
                                 record, details)
2215
1355
        self.assertEqual(None, res)
2216
1356
        self.assertTrue(parent_key in ann._pending_deltas)
2217
1357
        pending = ann._pending_deltas[parent_key]
2218
1358
        self.assertEqual(1, len(pending))
2219
1359
        self.assertEqual((rev_key, (parent_key,), record, details), pending[0])
2220
1360
2221
1361
    def test__expand_record_tracks_num_children(self):
2222
1362
        ann = self.make_annotator()
2223
1363
        rev_key = ('rev-id',)
2224
1364
        rev2_key = ('rev2-id',)
2225
1365
        parent_key = ('parent-id',)
2226
1366
        record = ['0,1,1\n', 'new-line\n']
2227
1367
        details = ('line-delta', False)
2228
1368
        ann._num_compression_children[parent_key] = 2
2229
1369
        ann._expand_record(parent_key, (), None, ['line1\n', 'line2\n'],
2230
1370
                           ('fulltext', False))
2231
1371
        res = ann._expand_record(rev_key, (parent_key,), parent_key,
2232
1372
                                 record, details)
2233
1373
        self.assertEqual({parent_key: 1}, ann._num_compression_children)
2234
1374
        # Expanding the second child should remove the content object, and the
2235
1375
        # num_compression_children entry
2236
1376
        res = ann._expand_record(rev2_key, (parent_key,), parent_key,
2237
1377
                                 record, details)
2238
1378
        self.assertFalse(parent_key in ann._content_objects)
2239
1379
        self.assertEqual({}, ann._num_compression_children)
2240
1380
        # We should not cache the content_objects for rev2 and rev, because
2241
1381
        # they do not have compression children of their own.
2242
1382
        self.assertEqual({}, ann._content_objects)
2243
1383
2244
1384
    def test__expand_delta_records_blocks(self):
2245
1385
        ann = self.make_annotator()
2246
1386
        rev_key = ('rev-id',)
2247
1387
        parent_key = ('parent-id',)
2248
1388
        record = ['0,1,1\n', 'new-line\n']
2249
1389
        details = ('line-delta', True)
2250
1390
        ann._num_compression_children[parent_key] = 2
2251
1391
        ann._expand_record(parent_key, (), None,
2252
1392
                           ['line1\n', 'line2\n', 'line3\n'],
2253
1393
                           ('fulltext', False))
2254
1394
        ann._expand_record(rev_key, (parent_key,), parent_key, record, details)
2255
1395
        self.assertEqual({(rev_key, parent_key): [(1, 1, 1), (3, 3, 0)]},
2256
1396
                         ann._matching_blocks)
2257
1397
        rev2_key = ('rev2-id',)
2258
1398
        record = ['0,1,1\n', 'new-line\n']
2259
1399
        details = ('line-delta', False)
2260
1400
        ann._expand_record(rev2_key, (parent_key,), parent_key, record, details)
2261
1401
        self.assertEqual([(1, 1, 2), (3, 3, 0)],
2262
1402
                         ann._matching_blocks[(rev2_key, parent_key)])
2263
1403
2264
1404
    def test__get_parent_ann_uses_matching_blocks(self):
2265
1405
        ann = self.make_annotator()
2266
1406
        rev_key = ('rev-id',)
2267
1407
        parent_key = ('parent-id',)
2268
1408
        parent_ann = [(parent_key,)]*3
2269
1409
        block_key = (rev_key, parent_key)
2270
1410
        ann._annotations_cache[parent_key] = parent_ann
2271
1411
        ann._matching_blocks[block_key] = [(0, 1, 1), (3, 3, 0)]
2272
1412
        # We should not try to access any parent_lines content, because we know
2273
1413
        # we already have the matching blocks
2274
1414
        par_ann, blocks = ann._get_parent_annotations_and_matches(rev_key,
2275
1415
                                        ['1\n', '2\n', '3\n'], parent_key)
2276
1416
        self.assertEqual(parent_ann, par_ann)
2277
1417
        self.assertEqual([(0, 1, 1), (3, 3, 0)], blocks)
2278
1418
        self.assertEqual({}, ann._matching_blocks)
2279
1419
2280
1420
    def test__process_pending(self):
2281
1421
        ann = self.make_annotator()
2282
1422
        rev_key = ('rev-id',)
2283
1423
        p1_key = ('p1-id',)
2284
1424
        p2_key = ('p2-id',)
2285
1425
        record = ['0,1,1\n', 'new-line\n']
2286
1426
        details = ('line-delta', False)
2287
1427
        p1_record = ['line1\n', 'line2\n']
2288
1428
        ann._num_compression_children[p1_key] = 1
2289
1429
        res = ann._expand_record(rev_key, (p1_key,p2_key), p1_key,
2290
1430
                                 record, details)
2291
1431
        self.assertEqual(None, res)
2292
1432
        # self.assertTrue(p1_key in ann._pending_deltas)
2293
1433
        self.assertEqual({}, ann._pending_annotation)
2294
1434
        # Now insert p1, and we should be able to expand the delta
2295
1435
        res = ann._expand_record(p1_key, (), None, p1_record,
2296
1436
                                 ('fulltext', False))
2297
1437
        self.assertEqual(p1_record, res)
2298
1438
        ann._annotations_cache[p1_key] = [(p1_key,)]*2
2299
1439
        res = ann._process_pending(p1_key)
2300
1440
        self.assertEqual([], res)
2301
1441
        self.assertFalse(p1_key in ann._pending_deltas)
2302
1442
        self.assertTrue(p2_key in ann._pending_annotation)
2303
1443
        self.assertEqual({p2_key: [(rev_key, (p1_key, p2_key))]},
2304
1444
                         ann._pending_annotation)
2305
1445
        # Now fill in parent 2, and pending annotation should be satisfied
2306
1446
        res = ann._expand_record(p2_key, (), None, [], ('fulltext', False))
2307
1447
        ann._annotations_cache[p2_key] = []
2308
1448
        res = ann._process_pending(p2_key)
2309
1449
        self.assertEqual([rev_key], res)
2310
1450
        self.assertEqual({}, ann._pending_annotation)
2311
1451
        self.assertEqual({}, ann._pending_deltas)
2312
1452
2313
1453
    def test_record_delta_removes_basis(self):
2314
1454
        ann = self.make_annotator()
2315
1455
        ann._expand_record(('parent-id',), (), None,
2316
1456
                           ['line1\n', 'line2\n'], ('fulltext', False))
2317
1457
        ann._num_compression_children['parent-id'] = 2
2318
1458
2319
1459
    def test_annotate_special_text(self):
2320
1460
        ann = self.make_annotator()
2321
1461
        vf = ann._vf
2322
1462
        rev1_key = ('rev-1',)
2323
1463
        rev2_key = ('rev-2',)
2324
1464
        rev3_key = ('rev-3',)
2325
1465
        spec_key = ('special:',)
2326
1466
        vf.add_lines(rev1_key, [], ['initial content\n'])
2327
1467
        vf.add_lines(rev2_key, [rev1_key], ['initial content\n',
2328
1468
                                            'common content\n',
2329
1469
                                            'content in 2\n'])
2330
1470
        vf.add_lines(rev3_key, [rev1_key], ['initial content\n',
2331
1471
                                            'common content\n',
2332
1472
                                            'content in 3\n'])
2333
1473
        spec_text = ('initial content\n'
2334
1474
                     'common content\n'
2335
1475
                     'content in 2\n'
2336
1476
                     'content in 3\n')
2337
1477
        ann.add_special_text(spec_key, [rev2_key, rev3_key], spec_text)
2338
1478
        anns, lines = ann.annotate(spec_key)
2339
1479
        self.assertEqual([(rev1_key,),
2340
1480
                          (rev2_key, rev3_key),
2341
1481
                          (rev2_key,),
2342
1482
                          (rev3_key,),
2343
1483
                         ], anns)
2344
1484
        self.assertEqualDiff(spec_text, ''.join(lines))
2345
1485
2346
1486
2347
1316
class KnitTests(TestCaseWithTransport):
1487
class KnitTests(TestCaseWithTransport):
2348
1317
    """Class containing knit test helper routines."""
1488
    """Class containing knit test helper routines."""
2349
1318
1489
2350
1319
1490
2351
=== modified file 'bzrlib/tests/test_versionedfile.py'
2352
--- bzrlib/tests/test_versionedfile.py	2009-06-22 15:37:06 +0000
2353
+++ bzrlib/tests/test_versionedfile.py	2009-07-08 23:35:28 +0000
2354
@@ -1557,6 +1557,42 @@
2355
1557
        self.assertRaises(RevisionNotPresent,
1557
        self.assertRaises(RevisionNotPresent,
2356
1558
            files.annotate, prefix + ('missing-key',))
1558
            files.annotate, prefix + ('missing-key',))
2357
1559
1559
2358
1560
    def test_get_annotator(self):
2359
1561
        files = self.get_versionedfiles()
2360
1562
        self.get_diamond_files(files)
2361
1563
        origin_key = self.get_simple_key('origin')
2362
1564
        base_key = self.get_simple_key('base')
2363
1565
        left_key = self.get_simple_key('left')
2364
1566
        right_key = self.get_simple_key('right')
2365
1567
        merged_key = self.get_simple_key('merged')
2366
1568
        # annotator = files.get_annotator()
2367
1569
        # introduced full text
2368
1570
        origins, lines = files.get_annotator().annotate(origin_key)
2369
1571
        self.assertEqual([(origin_key,)], origins)
2370
1572
        self.assertEqual(['origin\n'], lines)
2371
1573
        # a delta
2372
1574
        origins, lines = files.get_annotator().annotate(base_key)
2373
1575
        self.assertEqual([(base_key,)], origins)
2374
1576
        # a merge
2375
1577
        origins, lines = files.get_annotator().annotate(merged_key)
2376
1578
        if self.graph:
2377
1579
            self.assertEqual([
2378
1580
                (base_key,),
2379
1581
                (left_key,),
2380
1582
                (right_key,),
2381
1583
                (merged_key,),
2382
1584
                ], origins)
2383
1585
        else:
2384
1586
            # Without a graph everything is new.
2385
1587
            self.assertEqual([
2386
1588
                (merged_key,),
2387
1589
                (merged_key,),
2388
1590
                (merged_key,),
2389
1591
                (merged_key,),
2390
1592
                ], origins)
2391
1593
        self.assertRaises(RevisionNotPresent,
2392
1594
            files.get_annotator().annotate, self.get_simple_key('missing-key'))
2393
1595
2394
1560
    def test_construct(self):
1596
    def test_construct(self):
2395
1561
        """Each parameterised test can be constructed on a transport."""
1597
        """Each parameterised test can be constructed on a transport."""
2396
1562
        files = self.get_versionedfiles()
1598
        files = self.get_versionedfiles()
2397
1563
1599
2398
=== modified file 'bzrlib/tests/workingtree_implementations/__init__.py'
2399
--- bzrlib/tests/workingtree_implementations/__init__.py	2009-06-10 03:56:49 +0000
2400
+++ bzrlib/tests/workingtree_implementations/__init__.py	2009-07-08 23:35:28 +0000
2401
@@ -63,6 +63,7 @@
2402
63
    test_workingtree_implementations = [
63
    test_workingtree_implementations = [
2403
64
        'bzrlib.tests.workingtree_implementations.test_add_reference',
64
        'bzrlib.tests.workingtree_implementations.test_add_reference',
2404
65
        'bzrlib.tests.workingtree_implementations.test_add',
65
        'bzrlib.tests.workingtree_implementations.test_add',
2405
66
        'bzrlib.tests.workingtree_implementations.test_annotate_iter',
2406
66
        'bzrlib.tests.workingtree_implementations.test_basis_inventory',
67
        'bzrlib.tests.workingtree_implementations.test_basis_inventory',
2407
67
        'bzrlib.tests.workingtree_implementations.test_basis_tree',
68
        'bzrlib.tests.workingtree_implementations.test_basis_tree',
2408
68
        'bzrlib.tests.workingtree_implementations.test_break_lock',
69
        'bzrlib.tests.workingtree_implementations.test_break_lock',
2409
69
70
2410
=== added file 'bzrlib/tests/workingtree_implementations/test_annotate_iter.py'
2411
--- bzrlib/tests/workingtree_implementations/test_annotate_iter.py	1970-01-01 00:00:00 +0000
2412
+++ bzrlib/tests/workingtree_implementations/test_annotate_iter.py	2009-07-08 23:35:28 +0000
2413
@@ -0,0 +1,189 @@
2414
1
# Copyright (C) 2009 Canonical Ltd
2415
2
#
2416
3
# This program is free software; you can redistribute it and/or modify
2417
4
# it under the terms of the GNU General Public License as published by
2418
5
# the Free Software Foundation; either version 2 of the License, or
2419
6
# (at your option) any later version.
2420
7
#
2421
8
# This program is distributed in the hope that it will be useful,
2422
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2423
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2424
11
# GNU General Public License for more details.
2425
12
#
2426
13
# You should have received a copy of the GNU General Public License
2427
14
# along with this program; if not, write to the Free Software
2428
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
2429
16
2430
17
"""Tests for interface conformance of 'WorkingTree.annotate_iter'"""
2431
18
2432
19
import os
2433
20
2434
21
from bzrlib import (
2435
22
    errors,
2436
23
    inventory,
2437
24
    osutils,
2438
25
    tests,
2439
26
    )
2440
27
from bzrlib.tests.workingtree_implementations import TestCaseWithWorkingTree
2441
28
2442
29
2443
30
class TestAnnotateIter(TestCaseWithWorkingTree):
2444
31
2445
32
    def make_single_rev_tree(self):
2446
33
        builder = self.make_branch_builder('branch')
2447
34
        builder.build_snapshot('rev-1', None, [
2448
35
            ('add', ('', 'TREE_ROOT', 'directory', None)),
2449
36
            ('add', ('file', 'file-id', 'file', 'initial content\n')),
2450
37
            ])
2451
38
        b = builder.get_branch()
2452
39
        tree = b.create_checkout('tree', lightweight=True)
2453
40
        tree.lock_read()
2454
41
        self.addCleanup(tree.unlock)
2455
42
        return tree
2456
43
2457
44
    def test_annotate_same_as_parent(self):
2458
45
        tree = self.make_single_rev_tree()
2459
46
        annotations = tree.annotate_iter('file-id')
2460
47
        self.assertEqual([('rev-1', 'initial content\n')],
2461
48
                         annotations)
2462
49
2463
50
    def test_annotate_mod_from_parent(self):
2464
51
        tree = self.make_single_rev_tree()
2465
52
        self.build_tree_contents([('tree/file',
2466
53
                                   'initial content\nnew content\n')])
2467
54
        annotations = tree.annotate_iter('file-id')
2468
55
        self.assertEqual([('rev-1', 'initial content\n'),
2469
56
                          ('current:', 'new content\n'),
2470
57
                         ], annotations)
2471
58
2472
59
    def test_annotate_merge_parents(self):
2473
60
        builder = self.make_branch_builder('branch')
2474
61
        builder.start_series()
2475
62
        builder.build_snapshot('rev-1', None, [
2476
63
            ('add', ('', 'TREE_ROOT', 'directory', None)),
2477
64
            ('add', ('file', 'file-id', 'file', 'initial content\n')),
2478
65
            ])
2479
66
        builder.build_snapshot('rev-2', ['rev-1'], [
2480
67
            ('modify', ('file-id', 'initial content\ncontent in 2\n')),
2481
68
            ])
2482
69
        builder.build_snapshot('rev-3', ['rev-1'], [
2483
70
            ('modify', ('file-id', 'initial content\ncontent in 3\n')),
2484
71
            ])
2485
72
        builder.finish_series()
2486
73
        b = builder.get_branch()
2487
74
        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
2488
75
        tree.lock_write()
2489
76
        self.addCleanup(tree.unlock)
2490
77
        tree.set_parent_ids(['rev-2', 'rev-3'])
2491
78
        self.build_tree_contents([('tree/file',
2492
79
                                   'initial content\ncontent in 2\n'
2493
80
                                   'content in 3\nnew content\n')])
2494
81
        annotations = tree.annotate_iter('file-id')
2495
82
        self.assertEqual([('rev-1', 'initial content\n'),
2496
83
                          ('rev-2', 'content in 2\n'),
2497
84
                          ('rev-3', 'content in 3\n'),
2498
85
                          ('current:', 'new content\n'),
2499
86
                         ], annotations)
2500
87
2501
88
    def test_annotate_merge_parent_no_file(self):
2502
89
        builder = self.make_branch_builder('branch')
2503
90
        builder.start_series()
2504
91
        builder.build_snapshot('rev-1', None, [
2505
92
            ('add', ('', 'TREE_ROOT', 'directory', None)),
2506
93
            ])
2507
94
        builder.build_snapshot('rev-2', ['rev-1'], [
2508
95
            ('add', ('file', 'file-id', 'file', 'initial content\n')),
2509
96
            ])
2510
97
        builder.build_snapshot('rev-3', ['rev-1'], [])
2511
98
        builder.finish_series()
2512
99
        b = builder.get_branch()
2513
100
        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
2514
101
        tree.lock_write()
2515
102
        self.addCleanup(tree.unlock)
2516
103
        tree.set_parent_ids(['rev-2', 'rev-3'])
2517
104
        self.build_tree_contents([('tree/file',
2518
105
                                   'initial content\nnew content\n')])
2519
106
        annotations = tree.annotate_iter('file-id')
2520
107
        self.assertEqual([('rev-2', 'initial content\n'),
2521
108
                          ('current:', 'new content\n'),
2522
109
                         ], annotations)
2523
110
2524
111
    def test_annotate_merge_parent_was_directory(self):
2525
112
        builder = self.make_branch_builder('branch')
2526
113
        builder.start_series()
2527
114
        builder.build_snapshot('rev-1', None, [
2528
115
            ('add', ('', 'TREE_ROOT', 'directory', None)),
2529
116
            ])
2530
117
        builder.build_snapshot('rev-2', ['rev-1'], [
2531
118
            ('add', ('file', 'file-id', 'file', 'initial content\n')),
2532
119
            ])
2533
120
        builder.build_snapshot('rev-3', ['rev-1'], [
2534
121
            ('add', ('a_dir', 'file-id', 'directory', None)),
2535
122
            ])
2536
123
        builder.finish_series()
2537
124
        b = builder.get_branch()
2538
125
        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
2539
126
        tree.lock_write()
2540
127
        self.addCleanup(tree.unlock)
2541
128
        tree.set_parent_ids(['rev-2', 'rev-3'])
2542
129
        self.build_tree_contents([('tree/file',
2543
130
                                   'initial content\nnew content\n')])
2544
131
        annotations = tree.annotate_iter('file-id')
2545
132
        self.assertEqual([('rev-2', 'initial content\n'),
2546
133
                          ('current:', 'new content\n'),
2547
134
                         ], annotations)
2548
135
2549
136
    def test_annotate_same_as_merge_parent(self):
2550
137
        builder = self.make_branch_builder('branch')
2551
138
        builder.start_series()
2552
139
        builder.build_snapshot('rev-1', None, [
2553
140
            ('add', ('', 'TREE_ROOT', 'directory', None)),
2554
141
            ('add', ('file', 'file-id', 'file', 'initial content\n')),
2555
142
            ])
2556
143
        builder.build_snapshot('rev-2', ['rev-1'], [
2557
144
            ])
2558
145
        builder.build_snapshot('rev-3', ['rev-1'], [
2559
146
            ('modify', ('file-id', 'initial content\ncontent in 3\n')),
2560
147
            ])
2561
148
        builder.finish_series()
2562
149
        b = builder.get_branch()
2563
150
        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
2564
151
        tree.lock_write()
2565
152
        self.addCleanup(tree.unlock)
2566
153
        tree.set_parent_ids(['rev-2', 'rev-3'])
2567
154
        self.build_tree_contents([('tree/file',
2568
155
                                   'initial content\ncontent in 3\n')])
2569
156
        annotations = tree.annotate_iter('file-id')
2570
157
        self.assertEqual([('rev-1', 'initial content\n'),
2571
158
                          ('rev-3', 'content in 3\n'),
2572
159
                         ], annotations)
2573
160
2574
161
    def test_annotate_same_as_merge_parent_supersedes(self):
2575
162
        builder = self.make_branch_builder('branch')
2576
163
        builder.start_series()
2577
164
        builder.build_snapshot('rev-1', None, [
2578
165
            ('add', ('', 'TREE_ROOT', 'directory', None)),
2579
166
            ('add', ('file', 'file-id', 'file', 'initial content\n')),
2580
167
            ])
2581
168
        builder.build_snapshot('rev-2', ['rev-1'], [
2582
169
            ('modify', ('file-id', 'initial content\nnew content\n')),
2583
170
            ])
2584
171
        builder.build_snapshot('rev-3', ['rev-2'], [
2585
172
            ('modify', ('file-id', 'initial content\ncontent in 3\n')),
2586
173
            ])
2587
174
        builder.build_snapshot('rev-4', ['rev-3'], [
2588
175
            ('modify', ('file-id', 'initial content\nnew content\n')),
2589
176
            ])
2590
177
        # In this case, the content locally is the same as content in basis
2591
178
        # tree, but the merge revision states that *it* should win
2592
179
        builder.finish_series()
2593
180
        b = builder.get_branch()
2594
181
        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
2595
182
        tree.lock_write()
2596
183
        self.addCleanup(tree.unlock)
2597
184
        tree.set_parent_ids(['rev-2', 'rev-4'])
2598
185
        annotations = tree.annotate_iter('file-id')
2599
186
        self.assertEqual([('rev-1', 'initial content\n'),
2600
187
                          ('rev-4', 'new content\n'),
2601
188
                         ], annotations)
2602
189
2603
0
190
2604
=== modified file 'bzrlib/transform.py'
2605
--- bzrlib/transform.py	2009-06-30 04:08:12 +0000
2606
+++ bzrlib/transform.py	2009-07-08 23:35:27 +0000
2607
@@ -1,4 +1,4 @@
2609
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
1
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
2610
2
#
2
#
2611
3
# This program is free software; you can redistribute it and/or modify
3
# This program is free software; you can redistribute it and/or modify
2612
4
# it under the terms of the GNU General Public License as published by
4
# it under the terms of the GNU General Public License as published by
2613
@@ -1962,6 +1962,13 @@
2614
1962
            return old_annotation
1962
            return old_annotation
2615
1963
        if not changed_content:
1963
        if not changed_content:
2616
1964
            return old_annotation
1964
            return old_annotation
2617
1965
        # TODO: This is doing something similar to what WT.annotate_iter is
2618
1966
        #       doing, however it fails slightly because it doesn't know what
2619
1967
        #       the *other* revision_id is, so it doesn't know how to give the
2620
1968
        #       other as the origin for some lines, they all get
2621
1969
        #       'default_revision'
2622
1970
        #       It would be nice to be able to use the new Annotator based
2623
1971
        #       approach, as well.
2624
1965
        return annotate.reannotate([old_annotation],
1972
        return annotate.reannotate([old_annotation],
2625
1966
                                   self.get_file(file_id).readlines(),
1973
                                   self.get_file(file_id).readlines(),
2626
1967
                                   default_revision)
1974
                                   default_revision)
2627
1968
1975
2628
=== modified file 'bzrlib/versionedfile.py'
2629
--- bzrlib/versionedfile.py	2009-06-22 15:47:25 +0000
2630
+++ bzrlib/versionedfile.py	2009-07-08 23:35:28 +0000
2631
@@ -30,6 +30,7 @@
2632
30
import urllib
30
import urllib
2633
31
31
2634
32
from bzrlib import (
32
from bzrlib import (
2635
33
    annotate,
2636
33
    errors,
34
    errors,
2637
34
    groupcompress,
35
    groupcompress,
2638
35
    index,
36
    index,
2639
@@ -1122,6 +1123,9 @@
2640
1122
            result.append((prefix + (origin,), line))
1123
            result.append((prefix + (origin,), line))
2641
1123
        return result
1124
        return result
2642
1124
1125
2643
1126
    def get_annotator(self):
2644
1127
        return annotate.Annotator(self)
2645
1128
2646
1125
    def check(self, progress_bar=None):
1129
    def check(self, progress_bar=None):
2647
1126
        """See VersionedFiles.check()."""
1130
        """See VersionedFiles.check()."""
2648
1127
        for prefix, vf in self._iter_all_components():
1131
        for prefix, vf in self._iter_all_components():
2649
1128
1132
2650
=== modified file 'bzrlib/workingtree.py'
2651
--- bzrlib/workingtree.py	2009-07-01 10:40:07 +0000
2652
+++ bzrlib/workingtree.py	2009-07-08 23:35:28 +0000
2653
@@ -1,4 +1,4 @@
2655
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2656
2
#
2
#
2657
3
# This program is free software; you can redistribute it and/or modify
3
# This program is free software; you can redistribute it and/or modify
2658
4
# it under the terms of the GNU General Public License as published by
4
# it under the terms of the GNU General Public License as published by
2659
@@ -58,6 +58,7 @@
2660
58
    errors,
58
    errors,
2661
59
    generate_ids,
59
    generate_ids,
2662
60
    globbing,
60
    globbing,
2663
61
    graph as _mod_graph,
2664
61
    hashcache,
62
    hashcache,
2665
62
    ignores,
63
    ignores,
2666
63
    inventory,
64
    inventory,
2667
@@ -477,31 +478,42 @@
2668
477
        incorrectly attributed to CURRENT_REVISION (but after committing, the
478
        incorrectly attributed to CURRENT_REVISION (but after committing, the
2669
478
        attribution will be correct).
479
        attribution will be correct).
2670
479
        """
480
        """
2696
480
        basis = self.basis_tree()
481
        maybe_file_parent_keys = []
2697
481
        basis.lock_read()
482
        for parent_id in self.get_parent_ids():
2698
482
        try:
483
            try:
2699
483
            changes = self.iter_changes(basis, True, [self.id2path(file_id)],
484
                parent_tree = self.revision_tree(parent_id)
2700
484
                require_versioned=True).next()
485
            except errors.NoSuchRevisionInTree:
2701
485
            changed_content, kind = changes[2], changes[6]
486
                parent_tree = self.branch.repository.revision_tree(parent_id)
2702
486
            if not changed_content:
487
            parent_tree.lock_read()
2703
487
                return basis.annotate_iter(file_id)
488
            try:
2704
488
            if kind[1] is None:
489
                if file_id not in parent_tree:
2705
489
                return None
490
                    continue
2706
490
            import annotate
491
                ie = parent_tree.inventory[file_id]
2707
491
            if kind[0] != 'file':
492
                if ie.kind != 'file':
2708
492
                old_lines = []
493
                    # Note: this is slightly unnecessary, because symlinks and
2709
493
            else:
494
                    # directories have a "text" which is the empty text, and we
2710
494
                old_lines = list(basis.annotate_iter(file_id))
495
                    # know that won't mess up annotations. But it seems cleaner
2711
495
            old = [old_lines]
496
                    continue
2712
496
            for tree in self.branch.repository.revision_trees(
497
                parent_text_key = (file_id, ie.revision)
2713
497
                self.get_parent_ids()[1:]):
498
                if parent_text_key not in maybe_file_parent_keys:
2714
498
                if file_id not in tree:
499
                    maybe_file_parent_keys.append(parent_text_key)
2715
499
                    continue
500
            finally:
2716
500
                old.append(list(tree.annotate_iter(file_id)))
501
                parent_tree.unlock()
2717
501
            return annotate.reannotate(old, self.get_file(file_id).readlines(),
502
        graph = _mod_graph.Graph(self.branch.repository.texts)
2718
502
                                       default_revision)
503
        heads = graph.heads(maybe_file_parent_keys)
2719
503
        finally:
504
        file_parent_keys = []
2720
504
            basis.unlock()
505
        for key in maybe_file_parent_keys:
2721
506
            if key in heads:
2722
507
                file_parent_keys.append(key)
2723
508
2724
509
        # Now we have the parents of this content
2725
510
        annotator = self.branch.repository.texts.get_annotator()
2726
511
        text = self.get_file(file_id).read()
2727
512
        this_key =(file_id, default_revision)
2728
513
        annotator.add_special_text(this_key, file_parent_keys, text)
2729
514
        annotations = [(key[-1], line)
2730
515
                       for key, line in annotator.annotate_flat(this_key)]
2731
516
        return annotations
2732
505
517
2733
506
    def _get_ancestors(self, default_revision):
518
    def _get_ancestors(self, default_revision):
2734
507
        ancestors = set([default_revision])
519
        ancestors = set([default_revision])
2735
508
520
2736
=== modified file 'setup.py'
2737
--- setup.py	2009-06-23 07:10:03 +0000
2738
+++ setup.py	2009-07-08 23:35:27 +0000
2739
@@ -259,6 +259,7 @@
2740
259
        define_macros=define_macros, libraries=libraries))
259
        define_macros=define_macros, libraries=libraries))
2741
260
260
2742
261
261
2743
262
add_pyrex_extension('bzrlib._annotator_pyx')
2744
262
add_pyrex_extension('bzrlib._bencode_pyx')
263
add_pyrex_extension('bzrlib._bencode_pyx')
2745
263
add_pyrex_extension('bzrlib._btree_serializer_pyx')
264
add_pyrex_extension('bzrlib._btree_serializer_pyx')
2746
264
add_pyrex_extension('bzrlib._chunks_to_lines_pyx')
265
add_pyrex_extension('bzrlib._chunks_to_lines_pyx')
Reviewer	Date Requested	Status
Vincent Ladeuil	2009-07-07	Pending
bzr-core	2009-07-06	Pending
Review via email: mp+8281@code.launchpad.net