/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

(John Arbash Meinel)  Fix bug #158333,
        make sure that Repository.fetch(self) is properly a no-op for all
        Repository implementations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/versionedfile.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
7
7
# it under the terms of the GNU General Public License as published by
8
8
# the Free Software Foundation; either version 2 of the License, or
9
9
# (at your option) any later version.
10
 
 
 
10
#
11
11
# This program is distributed in the hope that it will be useful,
12
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
14
# GNU General Public License for more details.
15
 
 
 
15
#
16
16
# You should have received a copy of the GNU General Public License
17
17
# along with this program; if not, write to the Free Software
18
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
 
20
 
# Remaing to do is to figure out if get_graph should return a simple
21
 
# map, or a graph object of some kind.
22
 
 
23
 
 
24
20
"""Versioned text file storage api."""
25
21
 
26
 
 
27
 
from copy import deepcopy
28
 
from unittest import TestSuite
29
 
 
30
 
 
31
 
import bzrlib.errors as errors
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
 
24
 
 
25
from bzrlib import (
 
26
    errors,
 
27
    osutils,
 
28
    multiparent,
 
29
    tsort,
 
30
    revision,
 
31
    ui,
 
32
    )
 
33
from bzrlib.transport.memory import MemoryTransport
 
34
""")
 
35
 
 
36
from cStringIO import StringIO
 
37
 
32
38
from bzrlib.inter import InterObject
33
 
from bzrlib.symbol_versioning import *
34
 
from bzrlib.transport.memory import MemoryTransport
35
 
from bzrlib.tsort import topo_sort
36
 
from bzrlib import ui
 
39
from bzrlib.textmerge import TextMerge
37
40
 
38
41
 
39
42
class VersionedFile(object):
54
57
        self.finished = False
55
58
        self._access_mode = access_mode
56
59
 
 
60
    @staticmethod
 
61
    def check_not_reserved_id(version_id):
 
62
        revision.check_not_reserved_id(version_id)
 
63
 
57
64
    def copy_to(self, name, transport):
58
65
        """Copy this versioned file to name on transport."""
59
66
        raise NotImplementedError(self.copy_to)
60
 
    
61
 
    @deprecated_method(zero_eight)
62
 
    def names(self):
63
 
        """Return a list of all the versions in this versioned file.
64
 
 
65
 
        Please use versionedfile.versions() now.
66
 
        """
67
 
        return self.versions()
68
67
 
69
68
    def versions(self):
70
69
        """Return a unsorted list of versions."""
78
77
        """Returns whether version is present."""
79
78
        raise NotImplementedError(self.has_version)
80
79
 
81
 
    def add_delta(self, version_id, parents, delta_parent, sha1, noeol, delta):
82
 
        """Add a text to the versioned file via a pregenerated delta.
83
 
 
84
 
        :param version_id: The version id being added.
85
 
        :param parents: The parents of the version_id.
86
 
        :param delta_parent: The parent this delta was created against.
87
 
        :param sha1: The sha1 of the full text.
88
 
        :param delta: The delta instructions. See get_delta for details.
89
 
        """
90
 
        self._check_write_ok()
91
 
        if self.has_version(version_id):
92
 
            raise errors.RevisionAlreadyPresent(version_id, self)
93
 
        return self._add_delta(version_id, parents, delta_parent, sha1, noeol, delta)
94
 
 
95
 
    def _add_delta(self, version_id, parents, delta_parent, sha1, noeol, delta):
96
 
        """Class specific routine to add a delta.
97
 
 
98
 
        This generic version simply applies the delta to the delta_parent and
99
 
        then inserts it.
100
 
        """
101
 
        # strip annotation from delta
102
 
        new_delta = []
103
 
        for start, stop, delta_len, delta_lines in delta:
104
 
            new_delta.append((start, stop, delta_len, [text for origin, text in delta_lines]))
105
 
        if delta_parent is not None:
106
 
            parent_full = self.get_lines(delta_parent)
107
 
        else:
108
 
            parent_full = []
109
 
        new_full = self._apply_delta(parent_full, new_delta)
110
 
        # its impossible to have noeol on an empty file
111
 
        if noeol and new_full[-1][-1] == '\n':
112
 
            new_full[-1] = new_full[-1][:-1]
113
 
        self.add_lines(version_id, parents, new_full)
114
 
 
115
 
    def add_lines(self, version_id, parents, lines, parent_texts=None):
 
80
    def add_lines(self, version_id, parents, lines, parent_texts=None,
 
81
        left_matching_blocks=None, nostore_sha=None, random_id=False,
 
82
        check_content=True):
116
83
        """Add a single text on top of the versioned file.
117
84
 
118
85
        Must raise RevisionAlreadyPresent if the new version is
120
87
 
121
88
        Must raise RevisionNotPresent if any of the given parents are
122
89
        not present in file history.
 
90
 
 
91
        :param lines: A list of lines. Each line must be a bytestring. And all
 
92
            of them except the last must be terminated with \n and contain no
 
93
            other \n's. The last line may either contain no \n's or a single
 
94
            terminated \n. If the lines list does meet this constraint the add
 
95
            routine may error or may succeed - but you will be unable to read
 
96
            the data back accurately. (Checking the lines have been split
 
97
            correctly is expensive and extremely unlikely to catch bugs so it
 
98
            is not done at runtime unless check_content is True.)
123
99
        :param parent_texts: An optional dictionary containing the opaque 
124
 
             representations of some or all of the parents of 
125
 
             version_id to allow delta optimisations. 
126
 
             VERY IMPORTANT: the texts must be those returned
127
 
             by add_lines or data corruption can be caused.
128
 
        :return: An opaque representation of the inserted version which can be
129
 
                 provided back to future add_lines calls in the parent_texts
130
 
                 dictionary.
 
100
            representations of some or all of the parents of version_id to
 
101
            allow delta optimisations.  VERY IMPORTANT: the texts must be those
 
102
            returned by add_lines or data corruption can be caused.
 
103
        :param left_matching_blocks: a hint about which areas are common
 
104
            between the text and its left-hand-parent.  The format is
 
105
            the SequenceMatcher.get_matching_blocks format.
 
106
        :param nostore_sha: Raise ExistingContent and do not add the lines to
 
107
            the versioned file if the digest of the lines matches this.
 
108
        :param random_id: If True a random id has been selected rather than
 
109
            an id determined by some deterministic process such as a converter
 
110
            from a foreign VCS. When True the backend may choose not to check
 
111
            for uniqueness of the resulting key within the versioned file, so
 
112
            this should only be done when the result is expected to be unique
 
113
            anyway.
 
114
        :param check_content: If True, the lines supplied are verified to be
 
115
            bytestrings that are correctly formed lines.
 
116
        :return: The text sha1, the number of bytes in the text, and an opaque
 
117
                 representation of the inserted version which can be provided
 
118
                 back to future add_lines calls in the parent_texts dictionary.
131
119
        """
132
120
        self._check_write_ok()
133
 
        return self._add_lines(version_id, parents, lines, parent_texts)
 
121
        return self._add_lines(version_id, parents, lines, parent_texts,
 
122
            left_matching_blocks, nostore_sha, random_id, check_content)
134
123
 
135
 
    def _add_lines(self, version_id, parents, lines, parent_texts):
 
124
    def _add_lines(self, version_id, parents, lines, parent_texts,
 
125
        left_matching_blocks, nostore_sha, random_id, check_content):
136
126
        """Helper to do the class specific add_lines."""
137
127
        raise NotImplementedError(self.add_lines)
138
128
 
139
129
    def add_lines_with_ghosts(self, version_id, parents, lines,
140
 
                              parent_texts=None):
 
130
        parent_texts=None, nostore_sha=None, random_id=False,
 
131
        check_content=True):
141
132
        """Add lines to the versioned file, allowing ghosts to be present.
142
133
        
143
 
        This takes the same parameters as add_lines.
 
134
        This takes the same parameters as add_lines and returns the same.
144
135
        """
145
136
        self._check_write_ok()
146
137
        return self._add_lines_with_ghosts(version_id, parents, lines,
147
 
                                           parent_texts)
 
138
            parent_texts, nostore_sha, random_id, check_content)
148
139
 
149
 
    def _add_lines_with_ghosts(self, version_id, parents, lines, parent_texts):
 
140
    def _add_lines_with_ghosts(self, version_id, parents, lines, parent_texts,
 
141
        nostore_sha, random_id, check_content):
150
142
        """Helper to do class specific add_lines_with_ghosts."""
151
143
        raise NotImplementedError(self.add_lines_with_ghosts)
152
144
 
154
146
        """Check the versioned file for integrity."""
155
147
        raise NotImplementedError(self.check)
156
148
 
 
149
    def _check_lines_not_unicode(self, lines):
 
150
        """Check that lines being added to a versioned file are not unicode."""
 
151
        for line in lines:
 
152
            if line.__class__ is not str:
 
153
                raise errors.BzrBadParameterUnicode("lines")
 
154
 
 
155
    def _check_lines_are_lines(self, lines):
 
156
        """Check that the lines really are full lines without inline EOL."""
 
157
        for line in lines:
 
158
            if '\n' in line[:-1]:
 
159
                raise errors.BzrBadParameterContainsNewline("lines")
 
160
 
157
161
    def _check_write_ok(self):
158
162
        """Is the versioned file marked as 'finished' ? Raise if it is."""
159
163
        if self.finished:
161
165
        if self._access_mode != 'w':
162
166
            raise errors.ReadOnlyObjectDirtiedError(self)
163
167
 
 
168
    def enable_cache(self):
 
169
        """Tell this versioned file that it should cache any data it reads.
 
170
        
 
171
        This is advisory, implementations do not have to support caching.
 
172
        """
 
173
        pass
 
174
    
164
175
    def clear_cache(self):
165
 
        """Remove any data cached in the versioned file object."""
 
176
        """Remove any data cached in the versioned file object.
 
177
 
 
178
        This only needs to be supported if caches are supported
 
179
        """
 
180
        pass
166
181
 
167
182
    def clone_text(self, new_version_id, old_version_id, parents):
168
183
        """Add an identical text to old_version_id as new_version_id.
188
203
        """
189
204
        raise NotImplementedError(self.create_empty)
190
205
 
191
 
    def fix_parents(self, version, new_parents):
192
 
        """Fix the parents list for version.
193
 
        
194
 
        This is done by appending a new version to the index
195
 
        with identical data except for the parents list.
196
 
        the parents list must be a superset of the current
197
 
        list.
198
 
        """
199
 
        self._check_write_ok()
200
 
        return self._fix_parents(version, new_parents)
201
 
 
202
 
    def _fix_parents(self, version, new_parents):
203
 
        """Helper for fix_parents."""
204
 
        raise NotImplementedError(self.fix_parents)
205
 
 
206
 
    def get_delta(self, version):
207
 
        """Get a delta for constructing version from some other version.
208
 
        
209
 
        :return: (delta_parent, sha1, noeol, delta)
210
 
        Where delta_parent is a version id or None to indicate no parent.
211
 
        """
212
 
        raise NotImplementedError(self.get_delta)
213
 
 
214
 
    def get_deltas(self, versions):
215
 
        """Get multiple deltas at once for constructing versions.
216
 
        
217
 
        :return: dict(version_id:(delta_parent, sha1, noeol, delta))
218
 
        Where delta_parent is a version id or None to indicate no parent, and
219
 
        version_id is the version_id created by that delta.
220
 
        """
221
 
        result = {}
222
 
        for version in versions:
223
 
            result[version] = self.get_delta(version)
224
 
        return result
 
206
    def get_format_signature(self):
 
207
        """Get a text description of the data encoding in this file.
 
208
        
 
209
        :since: 0.90
 
210
        """
 
211
        raise NotImplementedError(self.get_format_signature)
 
212
 
 
213
    def make_mpdiffs(self, version_ids):
 
214
        """Create multiparent diffs for specified versions."""
 
215
        knit_versions = set()
 
216
        for version_id in version_ids:
 
217
            knit_versions.add(version_id)
 
218
            knit_versions.update(self.get_parents(version_id))
 
219
        lines = dict(zip(knit_versions,
 
220
            self._get_lf_split_line_list(knit_versions)))
 
221
        diffs = []
 
222
        for version_id in version_ids:
 
223
            target = lines[version_id]
 
224
            parents = [lines[p] for p in self.get_parents(version_id)]
 
225
            if len(parents) > 0:
 
226
                left_parent_blocks = self._extract_blocks(version_id,
 
227
                                                          parents[0], target)
 
228
            else:
 
229
                left_parent_blocks = None
 
230
            diffs.append(multiparent.MultiParent.from_lines(target, parents,
 
231
                         left_parent_blocks))
 
232
        return diffs
 
233
 
 
234
    def _extract_blocks(self, version_id, source, target):
 
235
        return None
 
236
 
 
237
    def add_mpdiffs(self, records):
 
238
        """Add mpdiffs to this VersionedFile.
 
239
 
 
240
        Records should be iterables of version, parents, expected_sha1,
 
241
        mpdiff. mpdiff should be a MultiParent instance.
 
242
        """
 
243
        # Does this need to call self._check_write_ok()? (IanC 20070919)
 
244
        vf_parents = {}
 
245
        mpvf = multiparent.MultiMemoryVersionedFile()
 
246
        versions = []
 
247
        for version, parent_ids, expected_sha1, mpdiff in records:
 
248
            versions.append(version)
 
249
            mpvf.add_diff(mpdiff, version, parent_ids)
 
250
        needed_parents = set()
 
251
        for version, parent_ids, expected_sha1, mpdiff in records:
 
252
            needed_parents.update(p for p in parent_ids
 
253
                                  if not mpvf.has_version(p))
 
254
        for parent_id, lines in zip(needed_parents,
 
255
                                 self._get_lf_split_line_list(needed_parents)):
 
256
            mpvf.add_version(lines, parent_id, [])
 
257
        for (version, parent_ids, expected_sha1, mpdiff), lines in\
 
258
            zip(records, mpvf.get_line_list(versions)):
 
259
            if len(parent_ids) == 1:
 
260
                left_matching_blocks = list(mpdiff.get_matching_blocks(0,
 
261
                    mpvf.get_diff(parent_ids[0]).num_lines()))
 
262
            else:
 
263
                left_matching_blocks = None
 
264
            _, _, version_text = self.add_lines(version, parent_ids, lines,
 
265
                vf_parents, left_matching_blocks=left_matching_blocks)
 
266
            vf_parents[version] = version_text
 
267
        for (version, parent_ids, expected_sha1, mpdiff), sha1 in\
 
268
             zip(records, self.get_sha1s(versions)):
 
269
            if expected_sha1 != sha1:
 
270
                raise errors.VersionedFileInvalidChecksum(version)
 
271
 
 
272
    def get_sha1(self, version_id):
 
273
        """Get the stored sha1 sum for the given revision.
 
274
        
 
275
        :param version_id: The name of the version to lookup
 
276
        """
 
277
        raise NotImplementedError(self.get_sha1)
 
278
 
 
279
    def get_sha1s(self, version_ids):
 
280
        """Get the stored sha1 sums for the given revisions.
 
281
 
 
282
        :param version_ids: The names of the versions to lookup
 
283
        :return: a list of sha1s in order according to the version_ids
 
284
        """
 
285
        raise NotImplementedError(self.get_sha1s)
225
286
 
226
287
    def get_suffixes(self):
227
288
        """Return the file suffixes associated with this versioned file."""
236
297
        return ''.join(self.get_lines(version_id))
237
298
    get_string = get_text
238
299
 
 
300
    def get_texts(self, version_ids):
 
301
        """Return the texts of listed versions as a list of strings.
 
302
 
 
303
        Raises RevisionNotPresent if version is not present in
 
304
        file history.
 
305
        """
 
306
        return [''.join(self.get_lines(v)) for v in version_ids]
 
307
 
239
308
    def get_lines(self, version_id):
240
309
        """Return version contents as a sequence of lines.
241
310
 
244
313
        """
245
314
        raise NotImplementedError(self.get_lines)
246
315
 
247
 
    def get_ancestry(self, version_ids):
 
316
    def _get_lf_split_line_list(self, version_ids):
 
317
        return [StringIO(t).readlines() for t in self.get_texts(version_ids)]
 
318
 
 
319
    def get_ancestry(self, version_ids, topo_sorted=True):
248
320
        """Return a list of all ancestors of given version(s). This
249
321
        will not include the null revision.
250
322
 
 
323
        This list will not be topologically sorted if topo_sorted=False is
 
324
        passed.
 
325
 
251
326
        Must raise RevisionNotPresent if any of the given versions are
252
327
        not present in file history."""
253
328
        if isinstance(version_ids, basestring):
266
341
        """
267
342
        raise NotImplementedError(self.get_ancestry_with_ghosts)
268
343
        
269
 
    def get_graph(self):
270
 
        """Return a graph for the entire versioned file.
 
344
    def get_graph(self, version_ids=None):
 
345
        """Return a graph from the versioned file. 
271
346
        
272
347
        Ghosts are not listed or referenced in the graph.
 
348
        :param version_ids: Versions to select.
 
349
                            None means retrieve all versions.
273
350
        """
 
351
        if version_ids is None:
 
352
            return dict(self.iter_parents(self.versions()))
274
353
        result = {}
275
 
        for version in self.versions():
276
 
            result[version] = self.get_parents(version)
 
354
        pending = set(version_ids)
 
355
        while pending:
 
356
            this_iteration = pending
 
357
            pending = set()
 
358
            for version, parents in self.iter_parents(this_iteration):
 
359
                result[version] = parents
 
360
                for parent in parents:
 
361
                    if parent in result:
 
362
                        continue
 
363
                    pending.add(parent)
277
364
        return result
278
365
 
279
366
    def get_graph_with_ghosts(self):
284
371
        """
285
372
        raise NotImplementedError(self.get_graph_with_ghosts)
286
373
 
287
 
    @deprecated_method(zero_eight)
288
 
    def parent_names(self, version):
289
 
        """Return version names for parents of a version.
290
 
        
291
 
        See get_parents for the current api.
292
 
        """
293
 
        return self.get_parents(version)
294
 
 
295
374
    def get_parents(self, version_id):
296
375
        """Return version names for parents of a version.
297
376
 
315
394
        """Yield list of (version-id, line) pairs for the specified
316
395
        version.
317
396
 
318
 
        Must raise RevisionNotPresent if any of the given versions are
 
397
        Must raise RevisionNotPresent if the given version is
319
398
        not present in file history.
320
399
        """
321
400
        raise NotImplementedError(self.annotate_iter)
323
402
    def annotate(self, version_id):
324
403
        return list(self.annotate_iter(version_id))
325
404
 
326
 
    def _apply_delta(self, lines, delta):
327
 
        """Apply delta to lines."""
328
 
        lines = list(lines)
329
 
        offset = 0
330
 
        for start, end, count, delta_lines in delta:
331
 
            lines[offset+start:offset+end] = delta_lines
332
 
            offset = offset + (start - end) + count
333
 
        return lines
334
 
 
335
405
    def join(self, other, pb=None, msg=None, version_ids=None,
336
406
             ignore_missing=False):
337
407
        """Integrate versions from other into this versioned file.
340
410
        incorporated into this versioned file.
341
411
 
342
412
        Must raise RevisionNotPresent if any of the specified versions
343
 
        are not present in the other files history unless ignore_missing
344
 
        is supplied when they are silently skipped.
 
413
        are not present in the other file's history unless ignore_missing
 
414
        is supplied in which case they are silently skipped.
345
415
        """
346
416
        self._check_write_ok()
347
417
        return InterVersionedFile.get(other, self).join(
350
420
            version_ids,
351
421
            ignore_missing)
352
422
 
353
 
    def iter_lines_added_or_present_in_versions(self, version_ids=None):
 
423
    def iter_lines_added_or_present_in_versions(self, version_ids=None,
 
424
                                                pb=None):
354
425
        """Iterate over the lines in the versioned file from version_ids.
355
426
 
356
 
        This may return lines from other versions, and does not return the
357
 
        specific version marker at this point. The api may be changed
358
 
        during development to include the version that the versioned file
359
 
        thinks is relevant, but given that such hints are just guesses,
360
 
        its better not to have it if we dont need it.
 
427
        This may return lines from other versions. Each item the returned
 
428
        iterator yields is a tuple of a line and a text version that that line
 
429
        is present in (not introduced in).
 
430
 
 
431
        Ordering of results is in whatever order is most suitable for the
 
432
        underlying storage format.
 
433
 
 
434
        If a progress bar is supplied, it may be used to indicate progress.
 
435
        The caller is responsible for cleaning up progress bars (because this
 
436
        is an iterator).
361
437
 
362
438
        NOTES: Lines are normalised: they will all have \n terminators.
363
439
               Lines are returned in arbitrary order.
 
440
 
 
441
        :return: An iterator over (line, version_id).
364
442
        """
365
443
        raise NotImplementedError(self.iter_lines_added_or_present_in_versions)
366
444
 
 
445
    def iter_parents(self, version_ids):
 
446
        """Iterate through the parents for many version ids.
 
447
 
 
448
        :param version_ids: An iterable yielding version_ids.
 
449
        :return: An iterator that yields (version_id, parents). Requested 
 
450
            version_ids not present in the versioned file are simply skipped.
 
451
            The order is undefined, allowing for different optimisations in
 
452
            the underlying implementation.
 
453
        """
 
454
        for version_id in version_ids:
 
455
            try:
 
456
                yield version_id, tuple(self.get_parents(version_id))
 
457
            except errors.RevisionNotPresent:
 
458
                pass
 
459
 
367
460
    def transaction_finished(self):
368
461
        """The transaction that this file was opened in has finished.
369
462
 
372
465
        """
373
466
        self.finished = True
374
467
 
375
 
    @deprecated_method(zero_eight)
376
 
    def walk(self, version_ids=None):
377
 
        """Walk the versioned file as a weave-like structure, for
378
 
        versions relative to version_ids.  Yields sequence of (lineno,
379
 
        insert, deletes, text) for each relevant line.
380
 
 
381
 
        Must raise RevisionNotPresent if any of the specified versions
382
 
        are not present in the file history.
383
 
 
384
 
        :param version_ids: the version_ids to walk with respect to. If not
385
 
                            supplied the entire weave-like structure is walked.
386
 
 
387
 
        walk is deprecated in favour of iter_lines_added_or_present_in_versions
388
 
        """
389
 
        raise NotImplementedError(self.walk)
390
 
 
391
 
    @deprecated_method(zero_eight)
392
 
    def iter_names(self):
393
 
        """Walk the names list."""
394
 
        return iter(self.versions())
395
 
 
396
468
    def plan_merge(self, ver_a, ver_b):
397
469
        """Return pseudo-annotation indicating how the two versions merge.
398
470
 
400
472
        base.
401
473
 
402
474
        Weave lines present in none of them are skipped entirely.
 
475
 
 
476
        Legend:
 
477
        killed-base Dead in base revision
 
478
        killed-both Killed in each revision
 
479
        killed-a    Killed in a
 
480
        killed-b    Killed in b
 
481
        unchanged   Alive in both a and b (possibly created in both)
 
482
        new-a       Created in a
 
483
        new-b       Created in b
 
484
        ghost-a     Killed in a, unborn in b    
 
485
        ghost-b     Killed in b, unborn in a
 
486
        irrelevant  Not in either revision
403
487
        """
404
 
        inc_a = set(self.get_ancestry([ver_a]))
405
 
        inc_b = set(self.get_ancestry([ver_b]))
406
 
        inc_c = inc_a & inc_b
407
 
 
408
 
        for lineno, insert, deleteset, line in self.walk([ver_a, ver_b]):
409
 
            if deleteset & inc_c:
410
 
                # killed in parent; can't be in either a or b
411
 
                # not relevant to our work
412
 
                yield 'killed-base', line
413
 
            elif insert in inc_c:
414
 
                # was inserted in base
415
 
                killed_a = bool(deleteset & inc_a)
416
 
                killed_b = bool(deleteset & inc_b)
417
 
                if killed_a and killed_b:
418
 
                    yield 'killed-both', line
419
 
                elif killed_a:
420
 
                    yield 'killed-a', line
421
 
                elif killed_b:
422
 
                    yield 'killed-b', line
423
 
                else:
424
 
                    yield 'unchanged', line
425
 
            elif insert in inc_a:
426
 
                if deleteset & inc_a:
427
 
                    yield 'ghost-a', line
428
 
                else:
429
 
                    # new in A; not in B
430
 
                    yield 'new-a', line
431
 
            elif insert in inc_b:
432
 
                if deleteset & inc_b:
433
 
                    yield 'ghost-b', line
434
 
                else:
435
 
                    yield 'new-b', line
436
 
            else:
437
 
                # not in either revision
438
 
                yield 'irrelevant', line
439
 
 
440
 
        yield 'unchanged', ''           # terminator
441
 
 
442
 
    def weave_merge(self, plan, a_marker='<<<<<<< \n', b_marker='>>>>>>> \n'):
 
488
        raise NotImplementedError(VersionedFile.plan_merge)
 
489
        
 
490
    def weave_merge(self, plan, a_marker=TextMerge.A_MARKER,
 
491
                    b_marker=TextMerge.B_MARKER):
 
492
        return PlanWeaveMerge(plan, a_marker, b_marker).merge_lines()[0]
 
493
 
 
494
 
 
495
class PlanWeaveMerge(TextMerge):
 
496
    """Weave merge that takes a plan as its input.
 
497
    
 
498
    This exists so that VersionedFile.plan_merge is implementable.
 
499
    Most callers will want to use WeaveMerge instead.
 
500
    """
 
501
 
 
502
    def __init__(self, plan, a_marker=TextMerge.A_MARKER,
 
503
                 b_marker=TextMerge.B_MARKER):
 
504
        TextMerge.__init__(self, a_marker, b_marker)
 
505
        self.plan = plan
 
506
 
 
507
    def _merge_struct(self):
443
508
        lines_a = []
444
509
        lines_b = []
445
510
        ch_a = ch_b = False
446
 
        # TODO: Return a structured form of the conflicts (e.g. 2-tuples for
447
 
        # conflicted regions), rather than just inserting the markers.
448
 
        # 
449
 
        # TODO: Show some version information (e.g. author, date) on 
450
 
        # conflicted regions.
451
 
        
 
511
 
 
512
        def outstanding_struct():
 
513
            if not lines_a and not lines_b:
 
514
                return
 
515
            elif ch_a and not ch_b:
 
516
                # one-sided change:
 
517
                yield(lines_a,)
 
518
            elif ch_b and not ch_a:
 
519
                yield (lines_b,)
 
520
            elif lines_a == lines_b:
 
521
                yield(lines_a,)
 
522
            else:
 
523
                yield (lines_a, lines_b)
 
524
       
452
525
        # We previously considered either 'unchanged' or 'killed-both' lines
453
526
        # to be possible places to resynchronize.  However, assuming agreement
454
 
        # on killed-both lines may be too agressive. -- mbp 20060324
455
 
        for state, line in plan:
 
527
        # on killed-both lines may be too aggressive. -- mbp 20060324
 
528
        for state, line in self.plan:
456
529
            if state == 'unchanged':
457
530
                # resync and flush queued conflicts changes if any
458
 
                if not lines_a and not lines_b:
459
 
                    pass
460
 
                elif ch_a and not ch_b:
461
 
                    # one-sided change:                    
462
 
                    for l in lines_a: yield l
463
 
                elif ch_b and not ch_a:
464
 
                    for l in lines_b: yield l
465
 
                elif lines_a == lines_b:
466
 
                    for l in lines_a: yield l
467
 
                else:
468
 
                    yield a_marker
469
 
                    for l in lines_a: yield l
470
 
                    yield '=======\n'
471
 
                    for l in lines_b: yield l
472
 
                    yield b_marker
473
 
 
474
 
                del lines_a[:]
475
 
                del lines_b[:]
 
531
                for struct in outstanding_struct():
 
532
                    yield struct
 
533
                lines_a = []
 
534
                lines_b = []
476
535
                ch_a = ch_b = False
477
536
                
478
537
            if state == 'unchanged':
479
538
                if line:
480
 
                    yield line
 
539
                    yield ([line],)
481
540
            elif state == 'killed-a':
482
541
                ch_a = True
483
542
                lines_b.append(line)
491
550
                ch_b = True
492
551
                lines_b.append(line)
493
552
            else:
494
 
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
495
 
                                 'killed-both'), \
496
 
                       state
 
553
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 
 
554
                                 'killed-base', 'killed-both'), state
 
555
        for struct in outstanding_struct():
 
556
            yield struct
 
557
 
 
558
 
 
559
class WeaveMerge(PlanWeaveMerge):
 
560
    """Weave merge that takes a VersionedFile and two versions as its input."""
 
561
 
 
562
    def __init__(self, versionedfile, ver_a, ver_b, 
 
563
        a_marker=PlanWeaveMerge.A_MARKER, b_marker=PlanWeaveMerge.B_MARKER):
 
564
        plan = versionedfile.plan_merge(ver_a, ver_b)
 
565
        PlanWeaveMerge.__init__(self, plan, a_marker, b_marker)
497
566
 
498
567
 
499
568
class InterVersionedFile(InterObject):
500
 
    """This class represents operations taking place between two versionedfiles..
 
569
    """This class represents operations taking place between two VersionedFiles.
501
570
 
502
571
    Its instances have methods like join, and contain
503
572
    references to the source and target versionedfiles these operations can be 
508
577
    InterVersionedFile.get(other).method_name(parameters).
509
578
    """
510
579
 
511
 
    _optimisers = set()
 
580
    _optimisers = []
512
581
    """The available optimised InterVersionedFile types."""
513
582
 
514
583
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
518
587
        incorporated into this versioned file.
519
588
 
520
589
        Must raise RevisionNotPresent if any of the specified versions
521
 
        are not present in the other files history unless ignore_missing is 
522
 
        supplied when they are silently skipped.
 
590
        are not present in the other file's history unless ignore_missing is 
 
591
        supplied in which case they are silently skipped.
523
592
        """
524
593
        # the default join: 
525
594
        # - if the target is empty, just add all the versions from 
533
602
            # Make a new target-format versioned file. 
534
603
            temp_source = self.target.create_empty("temp", MemoryTransport())
535
604
            target = temp_source
536
 
        graph = self.source.get_graph()
537
 
        order = topo_sort(graph.items())
 
605
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
 
606
        graph = self.source.get_graph(version_ids)
 
607
        order = tsort.topo_sort(graph.items())
538
608
        pb = ui.ui_factory.nested_progress_bar()
539
609
        parent_texts = {}
540
610
        try:
551
621
            # TODO: remove parent texts when they are not relevant any more for 
552
622
            # memory pressure reduction. RBC 20060313
553
623
            # pb.update('Converting versioned data', 0, len(order))
554
 
            # deltas = self.source.get_deltas(order)
 
624
            total = len(order)
555
625
            for index, version in enumerate(order):
556
 
                pb.update('Converting versioned data', index, len(order))
557
 
                parent_text = target.add_lines(version,
 
626
                pb.update('Converting versioned data', index, total)
 
627
                _, _, parent_text = target.add_lines(version,
558
628
                                               self.source.get_parents(version),
559
629
                                               self.source.get_lines(version),
560
630
                                               parent_texts=parent_texts)
561
631
                parent_texts[version] = parent_text
562
 
                #delta_parent, sha1, noeol, delta = deltas[version]
563
 
                #target.add_delta(version,
564
 
                #                 self.source.get_parents(version),
565
 
                #                 delta_parent,
566
 
                #                 sha1,
567
 
                #                 noeol,
568
 
                #                 delta)
569
 
                #target.get_lines(version)
570
632
            
571
633
            # this should hit the native code path for target
572
634
            if target is not self.target:
575
637
                                        msg,
576
638
                                        version_ids,
577
639
                                        ignore_missing)
 
640
            else:
 
641
                return total
578
642
        finally:
579
643
            pb.finished()
580
644
 
581
 
 
582
 
class InterVersionedFileTestProviderAdapter(object):
583
 
    """A tool to generate a suite testing multiple inter versioned-file classes.
584
 
 
585
 
    This is done by copying the test once for each interversionedfile provider
586
 
    and injecting the transport_server, transport_readonly_server,
587
 
    versionedfile_factory and versionedfile_factory_to classes into each copy.
588
 
    Each copy is also given a new id() to make it easy to identify.
589
 
    """
590
 
 
591
 
    def __init__(self, transport_server, transport_readonly_server, formats):
592
 
        self._transport_server = transport_server
593
 
        self._transport_readonly_server = transport_readonly_server
594
 
        self._formats = formats
595
 
    
596
 
    def adapt(self, test):
597
 
        result = TestSuite()
598
 
        for (interversionedfile_class,
599
 
             versionedfile_factory,
600
 
             versionedfile_factory_to) in self._formats:
601
 
            new_test = deepcopy(test)
602
 
            new_test.transport_server = self._transport_server
603
 
            new_test.transport_readonly_server = self._transport_readonly_server
604
 
            new_test.interversionedfile_class = interversionedfile_class
605
 
            new_test.versionedfile_factory = versionedfile_factory
606
 
            new_test.versionedfile_factory_to = versionedfile_factory_to
607
 
            def make_new_test_id():
608
 
                new_id = "%s(%s)" % (new_test.id(), interversionedfile_class.__name__)
609
 
                return lambda: new_id
610
 
            new_test.id = make_new_test_id()
611
 
            result.addTest(new_test)
612
 
        return result
613
 
 
614
 
    @staticmethod
615
 
    def default_test_list():
616
 
        """Generate the default list of interversionedfile permutations to test."""
617
 
        from bzrlib.weave import WeaveFile
618
 
        from bzrlib.knit import KnitVersionedFile
619
 
        result = []
620
 
        # test the fallback InterVersionedFile from weave to annotated knits
621
 
        result.append((InterVersionedFile, 
622
 
                       WeaveFile,
623
 
                       KnitVersionedFile))
624
 
        for optimiser in InterVersionedFile._optimisers:
625
 
            result.append((optimiser,
626
 
                           optimiser._matching_file_factory,
627
 
                           optimiser._matching_file_factory
628
 
                           ))
629
 
        # if there are specific combinations we want to use, we can add them 
630
 
        # here.
631
 
        return result
 
645
    def _get_source_version_ids(self, version_ids, ignore_missing):
 
646
        """Determine the version ids to be used from self.source.
 
647
 
 
648
        :param version_ids: The caller-supplied version ids to check. (None 
 
649
                            for all). If None is in version_ids, it is stripped.
 
650
        :param ignore_missing: if True, remove missing ids from the version 
 
651
                               list. If False, raise RevisionNotPresent on
 
652
                               a missing version id.
 
653
        :return: A set of version ids.
 
654
        """
 
655
        if version_ids is None:
 
656
            # None cannot be in source.versions
 
657
            return set(self.source.versions())
 
658
        else:
 
659
            if ignore_missing:
 
660
                return set(self.source.versions()).intersection(set(version_ids))
 
661
            else:
 
662
                new_version_ids = set()
 
663
                for version in version_ids:
 
664
                    if version is None:
 
665
                        continue
 
666
                    if not self.source.has_version(version):
 
667
                        raise errors.RevisionNotPresent(version, str(self.source))
 
668
                    else:
 
669
                        new_version_ids.add(version)
 
670
                return new_version_ids