~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Alexander Belchenko
  • Date: 2007-01-24 13:03:32 UTC
  • mto: This revision was merged to the branch mainline in revision 2242.
  • Revision ID: bialix@ukr.net-20070124130332-ane2eqz3eqrtm9u1
Use new API for testing

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# Authors:
 
4
#   Johan Rydberg <jrydberg@gnu.org>
 
5
#
 
6
# This program is free software; you can redistribute it and/or modify
 
7
# it under the terms of the GNU General Public License as published by
 
8
# the Free Software Foundation; either version 2 of the License, or
 
9
# (at your option) any later version.
 
10
#
 
11
# This program is distributed in the hope that it will be useful,
 
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
# GNU General Public License for more details.
 
15
#
 
16
# You should have received a copy of the GNU General Public License
 
17
# along with this program; if not, write to the Free Software
 
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 
 
20
"""Versioned text file storage api."""
 
21
 
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
from copy import deepcopy
 
25
import unittest
 
26
 
 
27
from bzrlib import (
 
28
    errors,
 
29
    tsort,
 
30
    ui,
 
31
    )
 
32
from bzrlib.transport.memory import MemoryTransport
 
33
""")
 
34
 
 
35
from bzrlib.inter import InterObject
 
36
from bzrlib.textmerge import TextMerge
 
37
from bzrlib.symbol_versioning import (deprecated_function,
 
38
        deprecated_method,
 
39
        zero_eight,
 
40
        )
 
41
 
 
42
 
 
43
class VersionedFile(object):
 
44
    """Versioned text file storage.
 
45
    
 
46
    A versioned file manages versions of line-based text files,
 
47
    keeping track of the originating version for each line.
 
48
 
 
49
    To clients the "lines" of the file are represented as a list of
 
50
    strings. These strings will typically have terminal newline
 
51
    characters, but this is not required.  In particular files commonly
 
52
    do not have a newline at the end of the file.
 
53
 
 
54
    Texts are identified by a version-id string.
 
55
    """
 
56
 
 
57
    def __init__(self, access_mode):
 
58
        self.finished = False
 
59
        self._access_mode = access_mode
 
60
 
 
61
    def copy_to(self, name, transport):
 
62
        """Copy this versioned file to name on transport."""
 
63
        raise NotImplementedError(self.copy_to)
 
64
 
 
65
    @deprecated_method(zero_eight)
 
66
    def names(self):
 
67
        """Return a list of all the versions in this versioned file.
 
68
 
 
69
        Please use versionedfile.versions() now.
 
70
        """
 
71
        return self.versions()
 
72
 
 
73
    def versions(self):
 
74
        """Return a unsorted list of versions."""
 
75
        raise NotImplementedError(self.versions)
 
76
 
 
77
    def has_ghost(self, version_id):
 
78
        """Returns whether version is present as a ghost."""
 
79
        raise NotImplementedError(self.has_ghost)
 
80
 
 
81
    def has_version(self, version_id):
 
82
        """Returns whether version is present."""
 
83
        raise NotImplementedError(self.has_version)
 
84
 
 
85
    def add_delta(self, version_id, parents, delta_parent, sha1, noeol, delta):
 
86
        """Add a text to the versioned file via a pregenerated delta.
 
87
 
 
88
        :param version_id: The version id being added.
 
89
        :param parents: The parents of the version_id.
 
90
        :param delta_parent: The parent this delta was created against.
 
91
        :param sha1: The sha1 of the full text.
 
92
        :param delta: The delta instructions. See get_delta for details.
 
93
        """
 
94
        self._check_write_ok()
 
95
        if self.has_version(version_id):
 
96
            raise errors.RevisionAlreadyPresent(version_id, self)
 
97
        return self._add_delta(version_id, parents, delta_parent, sha1, noeol, delta)
 
98
 
 
99
    def _add_delta(self, version_id, parents, delta_parent, sha1, noeol, delta):
 
100
        """Class specific routine to add a delta.
 
101
 
 
102
        This generic version simply applies the delta to the delta_parent and
 
103
        then inserts it.
 
104
        """
 
105
        # strip annotation from delta
 
106
        new_delta = []
 
107
        for start, stop, delta_len, delta_lines in delta:
 
108
            new_delta.append((start, stop, delta_len, [text for origin, text in delta_lines]))
 
109
        if delta_parent is not None:
 
110
            parent_full = self.get_lines(delta_parent)
 
111
        else:
 
112
            parent_full = []
 
113
        new_full = self._apply_delta(parent_full, new_delta)
 
114
        # its impossible to have noeol on an empty file
 
115
        if noeol and new_full[-1][-1] == '\n':
 
116
            new_full[-1] = new_full[-1][:-1]
 
117
        self.add_lines(version_id, parents, new_full)
 
118
 
 
119
    def add_lines(self, version_id, parents, lines, parent_texts=None):
 
120
        """Add a single text on top of the versioned file.
 
121
 
 
122
        Must raise RevisionAlreadyPresent if the new version is
 
123
        already present in file history.
 
124
 
 
125
        Must raise RevisionNotPresent if any of the given parents are
 
126
        not present in file history.
 
127
        :param parent_texts: An optional dictionary containing the opaque 
 
128
             representations of some or all of the parents of 
 
129
             version_id to allow delta optimisations. 
 
130
             VERY IMPORTANT: the texts must be those returned
 
131
             by add_lines or data corruption can be caused.
 
132
        :return: An opaque representation of the inserted version which can be
 
133
                 provided back to future add_lines calls in the parent_texts
 
134
                 dictionary.
 
135
        """
 
136
        self._check_write_ok()
 
137
        return self._add_lines(version_id, parents, lines, parent_texts)
 
138
 
 
139
    def _add_lines(self, version_id, parents, lines, parent_texts):
 
140
        """Helper to do the class specific add_lines."""
 
141
        raise NotImplementedError(self.add_lines)
 
142
 
 
143
    def add_lines_with_ghosts(self, version_id, parents, lines,
 
144
                              parent_texts=None):
 
145
        """Add lines to the versioned file, allowing ghosts to be present.
 
146
        
 
147
        This takes the same parameters as add_lines.
 
148
        """
 
149
        self._check_write_ok()
 
150
        return self._add_lines_with_ghosts(version_id, parents, lines,
 
151
                                           parent_texts)
 
152
 
 
153
    def _add_lines_with_ghosts(self, version_id, parents, lines, parent_texts):
 
154
        """Helper to do class specific add_lines_with_ghosts."""
 
155
        raise NotImplementedError(self.add_lines_with_ghosts)
 
156
 
 
157
    def check(self, progress_bar=None):
 
158
        """Check the versioned file for integrity."""
 
159
        raise NotImplementedError(self.check)
 
160
 
 
161
    def _check_lines_not_unicode(self, lines):
 
162
        """Check that lines being added to a versioned file are not unicode."""
 
163
        for line in lines:
 
164
            if line.__class__ is not str:
 
165
                raise errors.BzrBadParameterUnicode("lines")
 
166
 
 
167
    def _check_lines_are_lines(self, lines):
 
168
        """Check that the lines really are full lines without inline EOL."""
 
169
        for line in lines:
 
170
            if '\n' in line[:-1]:
 
171
                raise errors.BzrBadParameterContainsNewline("lines")
 
172
 
 
173
    def _check_write_ok(self):
 
174
        """Is the versioned file marked as 'finished' ? Raise if it is."""
 
175
        if self.finished:
 
176
            raise errors.OutSideTransaction()
 
177
        if self._access_mode != 'w':
 
178
            raise errors.ReadOnlyObjectDirtiedError(self)
 
179
 
 
180
    def enable_cache(self):
 
181
        """Tell this versioned file that it should cache any data it reads.
 
182
        
 
183
        This is advisory, implementations do not have to support caching.
 
184
        """
 
185
        pass
 
186
    
 
187
    def clear_cache(self):
 
188
        """Remove any data cached in the versioned file object.
 
189
 
 
190
        This only needs to be supported if caches are supported
 
191
        """
 
192
        pass
 
193
 
 
194
    def clone_text(self, new_version_id, old_version_id, parents):
 
195
        """Add an identical text to old_version_id as new_version_id.
 
196
 
 
197
        Must raise RevisionNotPresent if the old version or any of the
 
198
        parents are not present in file history.
 
199
 
 
200
        Must raise RevisionAlreadyPresent if the new version is
 
201
        already present in file history."""
 
202
        self._check_write_ok()
 
203
        return self._clone_text(new_version_id, old_version_id, parents)
 
204
 
 
205
    def _clone_text(self, new_version_id, old_version_id, parents):
 
206
        """Helper function to do the _clone_text work."""
 
207
        raise NotImplementedError(self.clone_text)
 
208
 
 
209
    def create_empty(self, name, transport, mode=None):
 
210
        """Create a new versioned file of this exact type.
 
211
 
 
212
        :param name: the file name
 
213
        :param transport: the transport
 
214
        :param mode: optional file mode.
 
215
        """
 
216
        raise NotImplementedError(self.create_empty)
 
217
 
 
218
    def fix_parents(self, version, new_parents):
 
219
        """Fix the parents list for version.
 
220
        
 
221
        This is done by appending a new version to the index
 
222
        with identical data except for the parents list.
 
223
        the parents list must be a superset of the current
 
224
        list.
 
225
        """
 
226
        self._check_write_ok()
 
227
        return self._fix_parents(version, new_parents)
 
228
 
 
229
    def _fix_parents(self, version, new_parents):
 
230
        """Helper for fix_parents."""
 
231
        raise NotImplementedError(self.fix_parents)
 
232
 
 
233
    def get_delta(self, version):
 
234
        """Get a delta for constructing version from some other version.
 
235
        
 
236
        :return: (delta_parent, sha1, noeol, delta)
 
237
        Where delta_parent is a version id or None to indicate no parent.
 
238
        """
 
239
        raise NotImplementedError(self.get_delta)
 
240
 
 
241
    def get_deltas(self, versions):
 
242
        """Get multiple deltas at once for constructing versions.
 
243
        
 
244
        :return: dict(version_id:(delta_parent, sha1, noeol, delta))
 
245
        Where delta_parent is a version id or None to indicate no parent, and
 
246
        version_id is the version_id created by that delta.
 
247
        """
 
248
        result = {}
 
249
        for version in versions:
 
250
            result[version] = self.get_delta(version)
 
251
        return result
 
252
 
 
253
    def get_sha1(self, version_id):
 
254
        """Get the stored sha1 sum for the given revision.
 
255
        
 
256
        :param name: The name of the version to lookup
 
257
        """
 
258
        raise NotImplementedError(self.get_sha1)
 
259
 
 
260
    def get_suffixes(self):
 
261
        """Return the file suffixes associated with this versioned file."""
 
262
        raise NotImplementedError(self.get_suffixes)
 
263
    
 
264
    def get_text(self, version_id):
 
265
        """Return version contents as a text string.
 
266
 
 
267
        Raises RevisionNotPresent if version is not present in
 
268
        file history.
 
269
        """
 
270
        return ''.join(self.get_lines(version_id))
 
271
    get_string = get_text
 
272
 
 
273
    def get_texts(self, version_ids):
 
274
        """Return the texts of listed versions as a list of strings.
 
275
 
 
276
        Raises RevisionNotPresent if version is not present in
 
277
        file history.
 
278
        """
 
279
        return [''.join(self.get_lines(v)) for v in version_ids]
 
280
 
 
281
    def get_lines(self, version_id):
 
282
        """Return version contents as a sequence of lines.
 
283
 
 
284
        Raises RevisionNotPresent if version is not present in
 
285
        file history.
 
286
        """
 
287
        raise NotImplementedError(self.get_lines)
 
288
 
 
289
    def get_ancestry(self, version_ids):
 
290
        """Return a list of all ancestors of given version(s). This
 
291
        will not include the null revision.
 
292
 
 
293
        Must raise RevisionNotPresent if any of the given versions are
 
294
        not present in file history."""
 
295
        if isinstance(version_ids, basestring):
 
296
            version_ids = [version_ids]
 
297
        raise NotImplementedError(self.get_ancestry)
 
298
        
 
299
    def get_ancestry_with_ghosts(self, version_ids):
 
300
        """Return a list of all ancestors of given version(s). This
 
301
        will not include the null revision.
 
302
 
 
303
        Must raise RevisionNotPresent if any of the given versions are
 
304
        not present in file history.
 
305
        
 
306
        Ghosts that are known about will be included in ancestry list,
 
307
        but are not explicitly marked.
 
308
        """
 
309
        raise NotImplementedError(self.get_ancestry_with_ghosts)
 
310
        
 
311
    def get_graph(self, version_ids=None):
 
312
        """Return a graph from the versioned file. 
 
313
        
 
314
        Ghosts are not listed or referenced in the graph.
 
315
        :param version_ids: Versions to select.
 
316
                            None means retrieve all versions.
 
317
        """
 
318
        result = {}
 
319
        if version_ids is None:
 
320
            for version in self.versions():
 
321
                result[version] = self.get_parents(version)
 
322
        else:
 
323
            pending = set(version_ids)
 
324
            while pending:
 
325
                version = pending.pop()
 
326
                if version in result:
 
327
                    continue
 
328
                parents = self.get_parents(version)
 
329
                for parent in parents:
 
330
                    if parent in result:
 
331
                        continue
 
332
                    pending.add(parent)
 
333
                result[version] = parents
 
334
        return result
 
335
 
 
336
    def get_graph_with_ghosts(self):
 
337
        """Return a graph for the entire versioned file.
 
338
        
 
339
        Ghosts are referenced in parents list but are not
 
340
        explicitly listed.
 
341
        """
 
342
        raise NotImplementedError(self.get_graph_with_ghosts)
 
343
 
 
344
    @deprecated_method(zero_eight)
 
345
    def parent_names(self, version):
 
346
        """Return version names for parents of a version.
 
347
        
 
348
        See get_parents for the current api.
 
349
        """
 
350
        return self.get_parents(version)
 
351
 
 
352
    def get_parents(self, version_id):
 
353
        """Return version names for parents of a version.
 
354
 
 
355
        Must raise RevisionNotPresent if version is not present in
 
356
        file history.
 
357
        """
 
358
        raise NotImplementedError(self.get_parents)
 
359
 
 
360
    def get_parents_with_ghosts(self, version_id):
 
361
        """Return version names for parents of version_id.
 
362
 
 
363
        Will raise RevisionNotPresent if version_id is not present
 
364
        in the history.
 
365
 
 
366
        Ghosts that are known about will be included in the parent list,
 
367
        but are not explicitly marked.
 
368
        """
 
369
        raise NotImplementedError(self.get_parents_with_ghosts)
 
370
 
 
371
    def annotate_iter(self, version_id):
 
372
        """Yield list of (version-id, line) pairs for the specified
 
373
        version.
 
374
 
 
375
        Must raise RevisionNotPresent if any of the given versions are
 
376
        not present in file history.
 
377
        """
 
378
        raise NotImplementedError(self.annotate_iter)
 
379
 
 
380
    def annotate(self, version_id):
 
381
        return list(self.annotate_iter(version_id))
 
382
 
 
383
    def _apply_delta(self, lines, delta):
 
384
        """Apply delta to lines."""
 
385
        lines = list(lines)
 
386
        offset = 0
 
387
        for start, end, count, delta_lines in delta:
 
388
            lines[offset+start:offset+end] = delta_lines
 
389
            offset = offset + (start - end) + count
 
390
        return lines
 
391
 
 
392
    def join(self, other, pb=None, msg=None, version_ids=None,
 
393
             ignore_missing=False):
 
394
        """Integrate versions from other into this versioned file.
 
395
 
 
396
        If version_ids is None all versions from other should be
 
397
        incorporated into this versioned file.
 
398
 
 
399
        Must raise RevisionNotPresent if any of the specified versions
 
400
        are not present in the other files history unless ignore_missing
 
401
        is supplied when they are silently skipped.
 
402
        """
 
403
        self._check_write_ok()
 
404
        return InterVersionedFile.get(other, self).join(
 
405
            pb,
 
406
            msg,
 
407
            version_ids,
 
408
            ignore_missing)
 
409
 
 
410
    def iter_lines_added_or_present_in_versions(self, version_ids=None, 
 
411
                                                pb=None):
 
412
        """Iterate over the lines in the versioned file from version_ids.
 
413
 
 
414
        This may return lines from other versions, and does not return the
 
415
        specific version marker at this point. The api may be changed
 
416
        during development to include the version that the versioned file
 
417
        thinks is relevant, but given that such hints are just guesses,
 
418
        its better not to have it if we don't need it.
 
419
 
 
420
        If a progress bar is supplied, it may be used to indicate progress.
 
421
        The caller is responsible for cleaning up progress bars (because this
 
422
        is an iterator).
 
423
 
 
424
        NOTES: Lines are normalised: they will all have \n terminators.
 
425
               Lines are returned in arbitrary order.
 
426
        """
 
427
        raise NotImplementedError(self.iter_lines_added_or_present_in_versions)
 
428
 
 
429
    def transaction_finished(self):
 
430
        """The transaction that this file was opened in has finished.
 
431
 
 
432
        This records self.finished = True and should cause all mutating
 
433
        operations to error.
 
434
        """
 
435
        self.finished = True
 
436
 
 
437
    @deprecated_method(zero_eight)
 
438
    def walk(self, version_ids=None):
 
439
        """Walk the versioned file as a weave-like structure, for
 
440
        versions relative to version_ids.  Yields sequence of (lineno,
 
441
        insert, deletes, text) for each relevant line.
 
442
 
 
443
        Must raise RevisionNotPresent if any of the specified versions
 
444
        are not present in the file history.
 
445
 
 
446
        :param version_ids: the version_ids to walk with respect to. If not
 
447
                            supplied the entire weave-like structure is walked.
 
448
 
 
449
        walk is deprecated in favour of iter_lines_added_or_present_in_versions
 
450
        """
 
451
        raise NotImplementedError(self.walk)
 
452
 
 
453
    @deprecated_method(zero_eight)
 
454
    def iter_names(self):
 
455
        """Walk the names list."""
 
456
        return iter(self.versions())
 
457
 
 
458
    def plan_merge(self, ver_a, ver_b):
 
459
        """Return pseudo-annotation indicating how the two versions merge.
 
460
 
 
461
        This is computed between versions a and b and their common
 
462
        base.
 
463
 
 
464
        Weave lines present in none of them are skipped entirely.
 
465
 
 
466
        Legend:
 
467
        killed-base Dead in base revision
 
468
        killed-both Killed in each revision
 
469
        killed-a    Killed in a
 
470
        killed-b    Killed in b
 
471
        unchanged   Alive in both a and b (possibly created in both)
 
472
        new-a       Created in a
 
473
        new-b       Created in b
 
474
        ghost-a     Killed in a, unborn in b    
 
475
        ghost-b     Killed in b, unborn in a
 
476
        irrelevant  Not in either revision
 
477
        """
 
478
        raise NotImplementedError(VersionedFile.plan_merge)
 
479
        
 
480
    def weave_merge(self, plan, a_marker=TextMerge.A_MARKER,
 
481
                    b_marker=TextMerge.B_MARKER):
 
482
        return PlanWeaveMerge(plan, a_marker, b_marker).merge_lines()[0]
 
483
 
 
484
 
 
485
class PlanWeaveMerge(TextMerge):
 
486
    """Weave merge that takes a plan as its input.
 
487
    
 
488
    This exists so that VersionedFile.plan_merge is implementable.
 
489
    Most callers will want to use WeaveMerge instead.
 
490
    """
 
491
 
 
492
    def __init__(self, plan, a_marker=TextMerge.A_MARKER,
 
493
                 b_marker=TextMerge.B_MARKER):
 
494
        TextMerge.__init__(self, a_marker, b_marker)
 
495
        self.plan = plan
 
496
 
 
497
    def _merge_struct(self):
 
498
        lines_a = []
 
499
        lines_b = []
 
500
        ch_a = ch_b = False
 
501
 
 
502
        def outstanding_struct():
 
503
            if not lines_a and not lines_b:
 
504
                return
 
505
            elif ch_a and not ch_b:
 
506
                # one-sided change:
 
507
                yield(lines_a,)
 
508
            elif ch_b and not ch_a:
 
509
                yield (lines_b,)
 
510
            elif lines_a == lines_b:
 
511
                yield(lines_a,)
 
512
            else:
 
513
                yield (lines_a, lines_b)
 
514
       
 
515
        # We previously considered either 'unchanged' or 'killed-both' lines
 
516
        # to be possible places to resynchronize.  However, assuming agreement
 
517
        # on killed-both lines may be too aggressive. -- mbp 20060324
 
518
        for state, line in self.plan:
 
519
            if state == 'unchanged':
 
520
                # resync and flush queued conflicts changes if any
 
521
                for struct in outstanding_struct():
 
522
                    yield struct
 
523
                lines_a = []
 
524
                lines_b = []
 
525
                ch_a = ch_b = False
 
526
                
 
527
            if state == 'unchanged':
 
528
                if line:
 
529
                    yield ([line],)
 
530
            elif state == 'killed-a':
 
531
                ch_a = True
 
532
                lines_b.append(line)
 
533
            elif state == 'killed-b':
 
534
                ch_b = True
 
535
                lines_a.append(line)
 
536
            elif state == 'new-a':
 
537
                ch_a = True
 
538
                lines_a.append(line)
 
539
            elif state == 'new-b':
 
540
                ch_b = True
 
541
                lines_b.append(line)
 
542
            else:
 
543
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 
 
544
                                 'killed-base', 'killed-both'), state
 
545
        for struct in outstanding_struct():
 
546
            yield struct
 
547
 
 
548
 
 
549
class WeaveMerge(PlanWeaveMerge):
 
550
    """Weave merge that takes a VersionedFile and two versions as its input"""
 
551
 
 
552
    def __init__(self, versionedfile, ver_a, ver_b, 
 
553
        a_marker=PlanWeaveMerge.A_MARKER, b_marker=PlanWeaveMerge.B_MARKER):
 
554
        plan = versionedfile.plan_merge(ver_a, ver_b)
 
555
        PlanWeaveMerge.__init__(self, plan, a_marker, b_marker)
 
556
 
 
557
 
 
558
class InterVersionedFile(InterObject):
 
559
    """This class represents operations taking place between two versionedfiles..
 
560
 
 
561
    Its instances have methods like join, and contain
 
562
    references to the source and target versionedfiles these operations can be 
 
563
    carried out on.
 
564
 
 
565
    Often we will provide convenience methods on 'versionedfile' which carry out
 
566
    operations with another versionedfile - they will always forward to
 
567
    InterVersionedFile.get(other).method_name(parameters).
 
568
    """
 
569
 
 
570
    _optimisers = []
 
571
    """The available optimised InterVersionedFile types."""
 
572
 
 
573
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
 
574
        """Integrate versions from self.source into self.target.
 
575
 
 
576
        If version_ids is None all versions from source should be
 
577
        incorporated into this versioned file.
 
578
 
 
579
        Must raise RevisionNotPresent if any of the specified versions
 
580
        are not present in the other files history unless ignore_missing is 
 
581
        supplied when they are silently skipped.
 
582
        """
 
583
        # the default join: 
 
584
        # - if the target is empty, just add all the versions from 
 
585
        #   source to target, otherwise:
 
586
        # - make a temporary versioned file of type target
 
587
        # - insert the source content into it one at a time
 
588
        # - join them
 
589
        if not self.target.versions():
 
590
            target = self.target
 
591
        else:
 
592
            # Make a new target-format versioned file. 
 
593
            temp_source = self.target.create_empty("temp", MemoryTransport())
 
594
            target = temp_source
 
595
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
 
596
        graph = self.source.get_graph(version_ids)
 
597
        order = tsort.topo_sort(graph.items())
 
598
        pb = ui.ui_factory.nested_progress_bar()
 
599
        parent_texts = {}
 
600
        try:
 
601
            # TODO for incremental cross-format work:
 
602
            # make a versioned file with the following content:
 
603
            # all revisions we have been asked to join
 
604
            # all their ancestors that are *not* in target already.
 
605
            # the immediate parents of the above two sets, with 
 
606
            # empty parent lists - these versions are in target already
 
607
            # and the incorrect version data will be ignored.
 
608
            # TODO: for all ancestors that are present in target already,
 
609
            # check them for consistent data, this requires moving sha1 from
 
610
            # 
 
611
            # TODO: remove parent texts when they are not relevant any more for 
 
612
            # memory pressure reduction. RBC 20060313
 
613
            # pb.update('Converting versioned data', 0, len(order))
 
614
            # deltas = self.source.get_deltas(order)
 
615
            for index, version in enumerate(order):
 
616
                pb.update('Converting versioned data', index, len(order))
 
617
                parent_text = target.add_lines(version,
 
618
                                               self.source.get_parents(version),
 
619
                                               self.source.get_lines(version),
 
620
                                               parent_texts=parent_texts)
 
621
                parent_texts[version] = parent_text
 
622
                #delta_parent, sha1, noeol, delta = deltas[version]
 
623
                #target.add_delta(version,
 
624
                #                 self.source.get_parents(version),
 
625
                #                 delta_parent,
 
626
                #                 sha1,
 
627
                #                 noeol,
 
628
                #                 delta)
 
629
                #target.get_lines(version)
 
630
            
 
631
            # this should hit the native code path for target
 
632
            if target is not self.target:
 
633
                return self.target.join(temp_source,
 
634
                                        pb,
 
635
                                        msg,
 
636
                                        version_ids,
 
637
                                        ignore_missing)
 
638
        finally:
 
639
            pb.finished()
 
640
 
 
641
    def _get_source_version_ids(self, version_ids, ignore_missing):
 
642
        """Determine the version ids to be used from self.source.
 
643
 
 
644
        :param version_ids: The caller-supplied version ids to check. (None 
 
645
                            for all). If None is in version_ids, it is stripped.
 
646
        :param ignore_missing: if True, remove missing ids from the version 
 
647
                               list. If False, raise RevisionNotPresent on
 
648
                               a missing version id.
 
649
        :return: A set of version ids.
 
650
        """
 
651
        if version_ids is None:
 
652
            # None cannot be in source.versions
 
653
            return set(self.source.versions())
 
654
        else:
 
655
            if ignore_missing:
 
656
                return set(self.source.versions()).intersection(set(version_ids))
 
657
            else:
 
658
                new_version_ids = set()
 
659
                for version in version_ids:
 
660
                    if version is None:
 
661
                        continue
 
662
                    if not self.source.has_version(version):
 
663
                        raise errors.RevisionNotPresent(version, str(self.source))
 
664
                    else:
 
665
                        new_version_ids.add(version)
 
666
                return new_version_ids
 
667
 
 
668
 
 
669
class InterVersionedFileTestProviderAdapter(object):
 
670
    """A tool to generate a suite testing multiple inter versioned-file classes.
 
671
 
 
672
    This is done by copying the test once for each InterVersionedFile provider
 
673
    and injecting the transport_server, transport_readonly_server,
 
674
    versionedfile_factory and versionedfile_factory_to classes into each copy.
 
675
    Each copy is also given a new id() to make it easy to identify.
 
676
    """
 
677
 
 
678
    def __init__(self, transport_server, transport_readonly_server, formats):
 
679
        self._transport_server = transport_server
 
680
        self._transport_readonly_server = transport_readonly_server
 
681
        self._formats = formats
 
682
    
 
683
    def adapt(self, test):
 
684
        result = unittest.TestSuite()
 
685
        for (interversionedfile_class,
 
686
             versionedfile_factory,
 
687
             versionedfile_factory_to) in self._formats:
 
688
            new_test = deepcopy(test)
 
689
            new_test.transport_server = self._transport_server
 
690
            new_test.transport_readonly_server = self._transport_readonly_server
 
691
            new_test.interversionedfile_class = interversionedfile_class
 
692
            new_test.versionedfile_factory = versionedfile_factory
 
693
            new_test.versionedfile_factory_to = versionedfile_factory_to
 
694
            def make_new_test_id():
 
695
                new_id = "%s(%s)" % (new_test.id(), interversionedfile_class.__name__)
 
696
                return lambda: new_id
 
697
            new_test.id = make_new_test_id()
 
698
            result.addTest(new_test)
 
699
        return result
 
700
 
 
701
    @staticmethod
 
702
    def default_test_list():
 
703
        """Generate the default list of interversionedfile permutations to test."""
 
704
        from bzrlib.weave import WeaveFile
 
705
        from bzrlib.knit import KnitVersionedFile
 
706
        result = []
 
707
        # test the fallback InterVersionedFile from annotated knits to weave
 
708
        result.append((InterVersionedFile, 
 
709
                       KnitVersionedFile,
 
710
                       WeaveFile))
 
711
        for optimiser in InterVersionedFile._optimisers:
 
712
            result.append((optimiser,
 
713
                           optimiser._matching_file_from_factory,
 
714
                           optimiser._matching_file_to_factory
 
715
                           ))
 
716
        # if there are specific combinations we want to use, we can add them 
 
717
        # here.
 
718
        return result