~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/versionedfile.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-16 14:01:20 UTC
  • mfrom: (3280.2.5 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080316140120-i3yq8yr1l66m11h7
Start 1.4 development

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# Authors:
4
4
#   Johan Rydberg <jrydberg@gnu.org>
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
 
20
20
"""Versioned text file storage api."""
21
21
 
22
 
from copy import copy
23
 
from cStringIO import StringIO
24
 
import os
25
 
import struct
26
 
from zlib import adler32
27
 
 
28
22
from bzrlib.lazy_import import lazy_import
29
23
lazy_import(globals(), """
30
 
import urllib
31
24
 
32
25
from bzrlib import (
33
26
    errors,
34
 
    groupcompress,
35
 
    index,
36
 
    knit,
37
27
    osutils,
38
28
    multiparent,
39
29
    tsort,
40
30
    revision,
41
31
    ui,
42
32
    )
43
 
from bzrlib.graph import DictParentsProvider, Graph, _StackedParentsProvider
44
33
from bzrlib.transport.memory import MemoryTransport
45
34
""")
 
35
 
 
36
from cStringIO import StringIO
 
37
 
46
38
from bzrlib.inter import InterObject
47
 
from bzrlib.registry import Registry
48
 
from bzrlib.symbol_versioning import *
49
39
from bzrlib.textmerge import TextMerge
50
 
from bzrlib.util import bencode
51
 
 
52
 
 
53
 
adapter_registry = Registry()
54
 
adapter_registry.register_lazy(('knit-delta-gz', 'fulltext'), 'bzrlib.knit',
55
 
    'DeltaPlainToFullText')
56
 
adapter_registry.register_lazy(('knit-ft-gz', 'fulltext'), 'bzrlib.knit',
57
 
    'FTPlainToFullText')
58
 
adapter_registry.register_lazy(('knit-annotated-delta-gz', 'knit-delta-gz'),
59
 
    'bzrlib.knit', 'DeltaAnnotatedToUnannotated')
60
 
adapter_registry.register_lazy(('knit-annotated-delta-gz', 'fulltext'),
61
 
    'bzrlib.knit', 'DeltaAnnotatedToFullText')
62
 
adapter_registry.register_lazy(('knit-annotated-ft-gz', 'knit-ft-gz'),
63
 
    'bzrlib.knit', 'FTAnnotatedToUnannotated')
64
 
adapter_registry.register_lazy(('knit-annotated-ft-gz', 'fulltext'),
65
 
    'bzrlib.knit', 'FTAnnotatedToFullText')
66
 
# adapter_registry.register_lazy(('knit-annotated-ft-gz', 'chunked'),
67
 
#     'bzrlib.knit', 'FTAnnotatedToChunked')
68
 
 
69
 
 
70
 
class ContentFactory(object):
71
 
    """Abstract interface for insertion and retrieval from a VersionedFile.
72
 
 
73
 
    :ivar sha1: None, or the sha1 of the content fulltext.
74
 
    :ivar storage_kind: The native storage kind of this factory. One of
75
 
        'mpdiff', 'knit-annotated-ft', 'knit-annotated-delta', 'knit-ft',
76
 
        'knit-delta', 'fulltext', 'knit-annotated-ft-gz',
77
 
        'knit-annotated-delta-gz', 'knit-ft-gz', 'knit-delta-gz'.
78
 
    :ivar key: The key of this content. Each key is a tuple with a single
79
 
        string in it.
80
 
    :ivar parents: A tuple of parent keys for self.key. If the object has
81
 
        no parent information, None (as opposed to () for an empty list of
82
 
        parents).
83
 
    """
84
 
 
85
 
    def __init__(self):
86
 
        """Create a ContentFactory."""
87
 
        self.sha1 = None
88
 
        self.storage_kind = None
89
 
        self.key = None
90
 
        self.parents = None
91
 
 
92
 
 
93
 
class ChunkedContentFactory(ContentFactory):
94
 
    """Static data content factory.
95
 
 
96
 
    This takes a 'chunked' list of strings. The only requirement on 'chunked' is
97
 
    that ''.join(lines) becomes a valid fulltext. A tuple of a single string
98
 
    satisfies this, as does a list of lines.
99
 
 
100
 
    :ivar sha1: None, or the sha1 of the content fulltext.
101
 
    :ivar storage_kind: The native storage kind of this factory. Always
102
 
        'chunked'
103
 
    :ivar key: The key of this content. Each key is a tuple with a single
104
 
        string in it.
105
 
    :ivar parents: A tuple of parent keys for self.key. If the object has
106
 
        no parent information, None (as opposed to () for an empty list of
107
 
        parents).
108
 
     """
109
 
 
110
 
    def __init__(self, key, parents, sha1, chunks):
111
 
        """Create a ContentFactory."""
112
 
        self.sha1 = sha1
113
 
        self.storage_kind = 'chunked'
114
 
        self.key = key
115
 
        self.parents = parents
116
 
        self._chunks = chunks
117
 
 
118
 
    def get_bytes_as(self, storage_kind):
119
 
        if storage_kind == 'chunked':
120
 
            return self._chunks
121
 
        elif storage_kind == 'fulltext':
122
 
            return ''.join(self._chunks)
123
 
        raise errors.UnavailableRepresentation(self.key, storage_kind,
124
 
            self.storage_kind)
125
 
 
126
 
 
127
 
class FulltextContentFactory(ContentFactory):
128
 
    """Static data content factory.
129
 
 
130
 
    This takes a fulltext when created and just returns that during
131
 
    get_bytes_as('fulltext').
132
 
 
133
 
    :ivar sha1: None, or the sha1 of the content fulltext.
134
 
    :ivar storage_kind: The native storage kind of this factory. Always
135
 
        'fulltext'.
136
 
    :ivar key: The key of this content. Each key is a tuple with a single
137
 
        string in it.
138
 
    :ivar parents: A tuple of parent keys for self.key. If the object has
139
 
        no parent information, None (as opposed to () for an empty list of
140
 
        parents).
141
 
     """
142
 
 
143
 
    def __init__(self, key, parents, sha1, text):
144
 
        """Create a ContentFactory."""
145
 
        self.sha1 = sha1
146
 
        self.storage_kind = 'fulltext'
147
 
        self.key = key
148
 
        self.parents = parents
149
 
        self._text = text
150
 
 
151
 
    def get_bytes_as(self, storage_kind):
152
 
        if storage_kind == self.storage_kind:
153
 
            return self._text
154
 
        elif storage_kind == 'chunked':
155
 
            return [self._text]
156
 
        raise errors.UnavailableRepresentation(self.key, storage_kind,
157
 
            self.storage_kind)
158
 
 
159
 
 
160
 
class AbsentContentFactory(ContentFactory):
161
 
    """A placeholder content factory for unavailable texts.
162
 
 
163
 
    :ivar sha1: None.
164
 
    :ivar storage_kind: 'absent'.
165
 
    :ivar key: The key of this content. Each key is a tuple with a single
166
 
        string in it.
167
 
    :ivar parents: None.
168
 
    """
169
 
 
170
 
    def __init__(self, key):
171
 
        """Create a ContentFactory."""
172
 
        self.sha1 = None
173
 
        self.storage_kind = 'absent'
174
 
        self.key = key
175
 
        self.parents = None
176
 
 
177
 
 
178
 
class AdapterFactory(ContentFactory):
179
 
    """A content factory to adapt between key prefix's."""
180
 
 
181
 
    def __init__(self, key, parents, adapted):
182
 
        """Create an adapter factory instance."""
183
 
        self.key = key
184
 
        self.parents = parents
185
 
        self._adapted = adapted
186
 
 
187
 
    def __getattr__(self, attr):
188
 
        """Return a member from the adapted object."""
189
 
        if attr in ('key', 'parents'):
190
 
            return self.__dict__[attr]
191
 
        else:
192
 
            return getattr(self._adapted, attr)
193
 
 
194
 
 
195
 
def filter_absent(record_stream):
196
 
    """Adapt a record stream to remove absent records."""
197
 
    for record in record_stream:
198
 
        if record.storage_kind != 'absent':
199
 
            yield record
200
40
 
201
41
 
202
42
class VersionedFile(object):
203
43
    """Versioned text file storage.
204
 
 
 
44
    
205
45
    A versioned file manages versions of line-based text files,
206
46
    keeping track of the originating version for each line.
207
47
 
213
53
    Texts are identified by a version-id string.
214
54
    """
215
55
 
 
56
    def __init__(self, access_mode):
 
57
        self.finished = False
 
58
        self._access_mode = access_mode
 
59
 
216
60
    @staticmethod
217
61
    def check_not_reserved_id(version_id):
218
62
        revision.check_not_reserved_id(version_id)
221
65
        """Copy this versioned file to name on transport."""
222
66
        raise NotImplementedError(self.copy_to)
223
67
 
224
 
    def get_record_stream(self, versions, ordering, include_delta_closure):
225
 
        """Get a stream of records for versions.
 
68
    def versions(self):
 
69
        """Return a unsorted list of versions."""
 
70
        raise NotImplementedError(self.versions)
226
71
 
227
 
        :param versions: The versions to include. Each version is a tuple
228
 
            (version,).
229
 
        :param ordering: Either 'unordered' or 'topological'. A topologically
230
 
            sorted stream has compression parents strictly before their
231
 
            children.
232
 
        :param include_delta_closure: If True then the closure across any
233
 
            compression parents will be included (in the data content of the
234
 
            stream, not in the emitted records). This guarantees that
235
 
            'fulltext' can be used successfully on every record.
236
 
        :return: An iterator of ContentFactory objects, each of which is only
237
 
            valid until the iterator is advanced.
238
 
        """
239
 
        raise NotImplementedError(self.get_record_stream)
 
72
    def has_ghost(self, version_id):
 
73
        """Returns whether version is present as a ghost."""
 
74
        raise NotImplementedError(self.has_ghost)
240
75
 
241
76
    def has_version(self, version_id):
242
77
        """Returns whether version is present."""
243
78
        raise NotImplementedError(self.has_version)
244
79
 
245
 
    def insert_record_stream(self, stream):
246
 
        """Insert a record stream into this versioned file.
247
 
 
248
 
        :param stream: A stream of records to insert.
249
 
        :return: None
250
 
        :seealso VersionedFile.get_record_stream:
251
 
        """
252
 
        raise NotImplementedError
253
 
 
254
80
    def add_lines(self, version_id, parents, lines, parent_texts=None,
255
81
        left_matching_blocks=None, nostore_sha=None, random_id=False,
256
82
        check_content=True):
270
96
            the data back accurately. (Checking the lines have been split
271
97
            correctly is expensive and extremely unlikely to catch bugs so it
272
98
            is not done at runtime unless check_content is True.)
273
 
        :param parent_texts: An optional dictionary containing the opaque
 
99
        :param parent_texts: An optional dictionary containing the opaque 
274
100
            representations of some or all of the parents of version_id to
275
101
            allow delta optimisations.  VERY IMPORTANT: the texts must be those
276
102
            returned by add_lines or data corruption can be caused.
302
128
 
303
129
    def add_lines_with_ghosts(self, version_id, parents, lines,
304
130
        parent_texts=None, nostore_sha=None, random_id=False,
305
 
        check_content=True, left_matching_blocks=None):
 
131
        check_content=True):
306
132
        """Add lines to the versioned file, allowing ghosts to be present.
307
 
 
 
133
        
308
134
        This takes the same parameters as add_lines and returns the same.
309
135
        """
310
136
        self._check_write_ok()
311
137
        return self._add_lines_with_ghosts(version_id, parents, lines,
312
 
            parent_texts, nostore_sha, random_id, check_content, left_matching_blocks)
 
138
            parent_texts, nostore_sha, random_id, check_content)
313
139
 
314
140
    def _add_lines_with_ghosts(self, version_id, parents, lines, parent_texts,
315
 
        nostore_sha, random_id, check_content, left_matching_blocks):
 
141
        nostore_sha, random_id, check_content):
316
142
        """Helper to do class specific add_lines_with_ghosts."""
317
143
        raise NotImplementedError(self.add_lines_with_ghosts)
318
144
 
332
158
            if '\n' in line[:-1]:
333
159
                raise errors.BzrBadParameterContainsNewline("lines")
334
160
 
 
161
    def _check_write_ok(self):
 
162
        """Is the versioned file marked as 'finished' ? Raise if it is."""
 
163
        if self.finished:
 
164
            raise errors.OutSideTransaction()
 
165
        if self._access_mode != 'w':
 
166
            raise errors.ReadOnlyObjectDirtiedError(self)
 
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
    
 
175
    def clear_cache(self):
 
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
 
181
 
 
182
    def clone_text(self, new_version_id, old_version_id, parents):
 
183
        """Add an identical text to old_version_id as new_version_id.
 
184
 
 
185
        Must raise RevisionNotPresent if the old version or any of the
 
186
        parents are not present in file history.
 
187
 
 
188
        Must raise RevisionAlreadyPresent if the new version is
 
189
        already present in file history."""
 
190
        self._check_write_ok()
 
191
        return self._clone_text(new_version_id, old_version_id, parents)
 
192
 
 
193
    def _clone_text(self, new_version_id, old_version_id, parents):
 
194
        """Helper function to do the _clone_text work."""
 
195
        raise NotImplementedError(self.clone_text)
 
196
 
 
197
    def create_empty(self, name, transport, mode=None):
 
198
        """Create a new versioned file of this exact type.
 
199
 
 
200
        :param name: the file name
 
201
        :param transport: the transport
 
202
        :param mode: optional file mode.
 
203
        """
 
204
        raise NotImplementedError(self.create_empty)
 
205
 
335
206
    def get_format_signature(self):
336
207
        """Get a text description of the data encoding in this file.
337
 
 
 
208
        
338
209
        :since: 0.90
339
210
        """
340
211
        raise NotImplementedError(self.get_format_signature)
342
213
    def make_mpdiffs(self, version_ids):
343
214
        """Create multiparent diffs for specified versions."""
344
215
        knit_versions = set()
345
 
        knit_versions.update(version_ids)
346
 
        parent_map = self.get_parent_map(version_ids)
347
216
        for version_id in version_ids:
348
 
            try:
349
 
                knit_versions.update(parent_map[version_id])
350
 
            except KeyError:
351
 
                raise errors.RevisionNotPresent(version_id, self)
352
 
        # We need to filter out ghosts, because we can't diff against them.
353
 
        knit_versions = set(self.get_parent_map(knit_versions).keys())
 
217
            knit_versions.add(version_id)
 
218
            knit_versions.update(self.get_parents(version_id))
354
219
        lines = dict(zip(knit_versions,
355
220
            self._get_lf_split_line_list(knit_versions)))
356
221
        diffs = []
357
222
        for version_id in version_ids:
358
223
            target = lines[version_id]
359
 
            try:
360
 
                parents = [lines[p] for p in parent_map[version_id] if p in
361
 
                    knit_versions]
362
 
            except KeyError:
363
 
                # I don't know how this could ever trigger.
364
 
                # parent_map[version_id] was already triggered in the previous
365
 
                # for loop, and lines[p] has the 'if p in knit_versions' check,
366
 
                # so we again won't have a KeyError.
367
 
                raise errors.RevisionNotPresent(version_id, self)
 
224
            parents = [lines[p] for p in self.get_parents(version_id)]
368
225
            if len(parents) > 0:
369
226
                left_parent_blocks = self._extract_blocks(version_id,
370
227
                                                          parents[0], target)
394
251
        for version, parent_ids, expected_sha1, mpdiff in records:
395
252
            needed_parents.update(p for p in parent_ids
396
253
                                  if not mpvf.has_version(p))
397
 
        present_parents = set(self.get_parent_map(needed_parents).keys())
398
 
        for parent_id, lines in zip(present_parents,
399
 
                                 self._get_lf_split_line_list(present_parents)):
 
254
        for parent_id, lines in zip(needed_parents,
 
255
                                 self._get_lf_split_line_list(needed_parents)):
400
256
            mpvf.add_version(lines, parent_id, [])
401
257
        for (version, parent_ids, expected_sha1, mpdiff), lines in\
402
258
            zip(records, mpvf.get_line_list(versions)):
405
261
                    mpvf.get_diff(parent_ids[0]).num_lines()))
406
262
            else:
407
263
                left_matching_blocks = None
408
 
            try:
409
 
                _, _, version_text = self.add_lines_with_ghosts(version,
410
 
                    parent_ids, lines, vf_parents,
411
 
                    left_matching_blocks=left_matching_blocks)
412
 
            except NotImplementedError:
413
 
                # The vf can't handle ghosts, so add lines normally, which will
414
 
                # (reasonably) fail if there are ghosts in the data.
415
 
                _, _, version_text = self.add_lines(version,
416
 
                    parent_ids, lines, vf_parents,
417
 
                    left_matching_blocks=left_matching_blocks)
 
264
            _, _, version_text = self.add_lines(version, parent_ids, lines,
 
265
                vf_parents, left_matching_blocks=left_matching_blocks)
418
266
            vf_parents[version] = version_text
419
 
        sha1s = self.get_sha1s(versions)
420
 
        for version, parent_ids, expected_sha1, mpdiff in records:
421
 
            if expected_sha1 != sha1s[version]:
 
267
        for (version, parent_ids, expected_sha1, mpdiff), sha1 in\
 
268
             zip(records, self.get_sha1s(versions)):
 
269
            if expected_sha1 != sha1:
422
270
                raise errors.VersionedFileInvalidChecksum(version)
423
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)
 
286
 
 
287
    def get_suffixes(self):
 
288
        """Return the file suffixes associated with this versioned file."""
 
289
        raise NotImplementedError(self.get_suffixes)
 
290
    
424
291
    def get_text(self, version_id):
425
292
        """Return version contents as a text string.
426
293
 
461
328
        if isinstance(version_ids, basestring):
462
329
            version_ids = [version_ids]
463
330
        raise NotImplementedError(self.get_ancestry)
464
 
 
 
331
        
465
332
    def get_ancestry_with_ghosts(self, version_ids):
466
333
        """Return a list of all ancestors of given version(s). This
467
334
        will not include the null revision.
468
335
 
469
336
        Must raise RevisionNotPresent if any of the given versions are
470
337
        not present in file history.
471
 
 
 
338
        
472
339
        Ghosts that are known about will be included in ancestry list,
473
340
        but are not explicitly marked.
474
341
        """
475
342
        raise NotImplementedError(self.get_ancestry_with_ghosts)
476
 
 
477
 
    def get_parent_map(self, version_ids):
478
 
        """Get a map of the parents of version_ids.
479
 
 
480
 
        :param version_ids: The version ids to look up parents for.
481
 
        :return: A mapping from version id to parents.
482
 
        """
483
 
        raise NotImplementedError(self.get_parent_map)
 
343
        
 
344
    def get_graph(self, version_ids=None):
 
345
        """Return a graph from the versioned file. 
 
346
        
 
347
        Ghosts are not listed or referenced in the graph.
 
348
        :param version_ids: Versions to select.
 
349
                            None means retrieve all versions.
 
350
        """
 
351
        if version_ids is None:
 
352
            return dict(self.iter_parents(self.versions()))
 
353
        result = {}
 
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)
 
364
        return result
 
365
 
 
366
    def get_graph_with_ghosts(self):
 
367
        """Return a graph for the entire versioned file.
 
368
        
 
369
        Ghosts are referenced in parents list but are not
 
370
        explicitly listed.
 
371
        """
 
372
        raise NotImplementedError(self.get_graph_with_ghosts)
 
373
 
 
374
    def get_parents(self, version_id):
 
375
        """Return version names for parents of a version.
 
376
 
 
377
        Must raise RevisionNotPresent if version is not present in
 
378
        file history.
 
379
        """
 
380
        raise NotImplementedError(self.get_parents)
484
381
 
485
382
    def get_parents_with_ghosts(self, version_id):
486
383
        """Return version names for parents of version_id.
491
388
        Ghosts that are known about will be included in the parent list,
492
389
        but are not explicitly marked.
493
390
        """
494
 
        try:
495
 
            return list(self.get_parent_map([version_id])[version_id])
496
 
        except KeyError:
497
 
            raise errors.RevisionNotPresent(version_id, self)
 
391
        raise NotImplementedError(self.get_parents_with_ghosts)
 
392
 
 
393
    def annotate_iter(self, version_id):
 
394
        """Yield list of (version-id, line) pairs for the specified
 
395
        version.
 
396
 
 
397
        Must raise RevisionNotPresent if the given version is
 
398
        not present in file history.
 
399
        """
 
400
        raise NotImplementedError(self.annotate_iter)
498
401
 
499
402
    def annotate(self, version_id):
500
 
        """Return a list of (version-id, line) tuples for version_id.
501
 
 
502
 
        :raise RevisionNotPresent: If the given version is
503
 
        not present in file history.
 
403
        return list(self.annotate_iter(version_id))
 
404
 
 
405
    def join(self, other, pb=None, msg=None, version_ids=None,
 
406
             ignore_missing=False):
 
407
        """Integrate versions from other into this versioned file.
 
408
 
 
409
        If version_ids is None all versions from other should be
 
410
        incorporated into this versioned file.
 
411
 
 
412
        Must raise RevisionNotPresent if any of the specified versions
 
413
        are not present in the other file's history unless ignore_missing
 
414
        is supplied in which case they are silently skipped.
504
415
        """
505
 
        raise NotImplementedError(self.annotate)
 
416
        self._check_write_ok()
 
417
        return InterVersionedFile.get(other, self).join(
 
418
            pb,
 
419
            msg,
 
420
            version_ids,
 
421
            ignore_missing)
506
422
 
507
423
    def iter_lines_added_or_present_in_versions(self, version_ids=None,
508
424
                                                pb=None):
526
442
        """
527
443
        raise NotImplementedError(self.iter_lines_added_or_present_in_versions)
528
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
 
 
460
    def transaction_finished(self):
 
461
        """The transaction that this file was opened in has finished.
 
462
 
 
463
        This records self.finished = True and should cause all mutating
 
464
        operations to error.
 
465
        """
 
466
        self.finished = True
 
467
 
529
468
    def plan_merge(self, ver_a, ver_b):
530
469
        """Return pseudo-annotation indicating how the two versions merge.
531
470
 
542
481
        unchanged   Alive in both a and b (possibly created in both)
543
482
        new-a       Created in a
544
483
        new-b       Created in b
545
 
        ghost-a     Killed in a, unborn in b
 
484
        ghost-a     Killed in a, unborn in b    
546
485
        ghost-b     Killed in b, unborn in a
547
486
        irrelevant  Not in either revision
548
487
        """
549
488
        raise NotImplementedError(VersionedFile.plan_merge)
550
 
 
 
489
        
551
490
    def weave_merge(self, plan, a_marker=TextMerge.A_MARKER,
552
491
                    b_marker=TextMerge.B_MARKER):
553
492
        return PlanWeaveMerge(plan, a_marker, b_marker).merge_lines()[0]
554
493
 
555
494
 
556
 
class RecordingVersionedFilesDecorator(object):
557
 
    """A minimal versioned files that records calls made on it.
558
 
 
559
 
    Only enough methods have been added to support tests using it to date.
560
 
 
561
 
    :ivar calls: A list of the calls made; can be reset at any time by
562
 
        assigning [] to it.
563
 
    """
564
 
 
565
 
    def __init__(self, backing_vf):
566
 
        """Create a RecordingVersionedFilesDecorator decorating backing_vf.
567
 
 
568
 
        :param backing_vf: The versioned file to answer all methods.
569
 
        """
570
 
        self._backing_vf = backing_vf
571
 
        self.calls = []
572
 
 
573
 
    def add_lines(self, key, parents, lines, parent_texts=None,
574
 
        left_matching_blocks=None, nostore_sha=None, random_id=False,
575
 
        check_content=True):
576
 
        self.calls.append(("add_lines", key, parents, lines, parent_texts,
577
 
            left_matching_blocks, nostore_sha, random_id, check_content))
578
 
        return self._backing_vf.add_lines(key, parents, lines, parent_texts,
579
 
            left_matching_blocks, nostore_sha, random_id, check_content)
580
 
 
581
 
    def check(self):
582
 
        self._backing_vf.check()
583
 
 
584
 
    def get_parent_map(self, keys):
585
 
        self.calls.append(("get_parent_map", copy(keys)))
586
 
        return self._backing_vf.get_parent_map(keys)
587
 
 
588
 
    def get_record_stream(self, keys, sort_order, include_delta_closure):
589
 
        self.calls.append(("get_record_stream", list(keys), sort_order,
590
 
            include_delta_closure))
591
 
        return self._backing_vf.get_record_stream(keys, sort_order,
592
 
            include_delta_closure)
593
 
 
594
 
    def get_sha1s(self, keys):
595
 
        self.calls.append(("get_sha1s", copy(keys)))
596
 
        return self._backing_vf.get_sha1s(keys)
597
 
 
598
 
    def iter_lines_added_or_present_in_keys(self, keys, pb=None):
599
 
        self.calls.append(("iter_lines_added_or_present_in_keys", copy(keys)))
600
 
        return self._backing_vf.iter_lines_added_or_present_in_keys(keys, pb=pb)
601
 
 
602
 
    def keys(self):
603
 
        self.calls.append(("keys",))
604
 
        return self._backing_vf.keys()
605
 
 
606
 
 
607
 
class OrderingVersionedFilesDecorator(RecordingVersionedFilesDecorator):
608
 
    """A VF that records calls, and returns keys in specific order.
609
 
 
610
 
    :ivar calls: A list of the calls made; can be reset at any time by
611
 
        assigning [] to it.
612
 
    """
613
 
 
614
 
    def __init__(self, backing_vf, key_priority):
615
 
        """Create a RecordingVersionedFilesDecorator decorating backing_vf.
616
 
 
617
 
        :param backing_vf: The versioned file to answer all methods.
618
 
        :param key_priority: A dictionary defining what order keys should be
619
 
            returned from an 'unordered' get_record_stream request.
620
 
            Keys with lower priority are returned first, keys not present in
621
 
            the map get an implicit priority of 0, and are returned in
622
 
            lexicographical order.
623
 
        """
624
 
        RecordingVersionedFilesDecorator.__init__(self, backing_vf)
625
 
        self._key_priority = key_priority
626
 
 
627
 
    def get_record_stream(self, keys, sort_order, include_delta_closure):
628
 
        self.calls.append(("get_record_stream", list(keys), sort_order,
629
 
            include_delta_closure))
630
 
        if sort_order == 'unordered':
631
 
            def sort_key(key):
632
 
                return (self._key_priority.get(key, 0), key)
633
 
            # Use a defined order by asking for the keys one-by-one from the
634
 
            # backing_vf
635
 
            for key in sorted(keys, key=sort_key):
636
 
                for record in self._backing_vf.get_record_stream([key],
637
 
                                'unordered', include_delta_closure):
638
 
                    yield record
639
 
        else:
640
 
            for record in self._backing_vf.get_record_stream(keys, sort_order,
641
 
                            include_delta_closure):
642
 
                yield record
643
 
 
644
 
 
645
 
class KeyMapper(object):
646
 
    """KeyMappers map between keys and underlying partitioned storage."""
647
 
 
648
 
    def map(self, key):
649
 
        """Map key to an underlying storage identifier.
650
 
 
651
 
        :param key: A key tuple e.g. ('file-id', 'revision-id').
652
 
        :return: An underlying storage identifier, specific to the partitioning
653
 
            mechanism.
654
 
        """
655
 
        raise NotImplementedError(self.map)
656
 
 
657
 
    def unmap(self, partition_id):
658
 
        """Map a partitioned storage id back to a key prefix.
659
 
 
660
 
        :param partition_id: The underlying partition id.
661
 
        :return: As much of a key (or prefix) as is derivable from the partition
662
 
            id.
663
 
        """
664
 
        raise NotImplementedError(self.unmap)
665
 
 
666
 
 
667
 
class ConstantMapper(KeyMapper):
668
 
    """A key mapper that maps to a constant result."""
669
 
 
670
 
    def __init__(self, result):
671
 
        """Create a ConstantMapper which will return result for all maps."""
672
 
        self._result = result
673
 
 
674
 
    def map(self, key):
675
 
        """See KeyMapper.map()."""
676
 
        return self._result
677
 
 
678
 
 
679
 
class URLEscapeMapper(KeyMapper):
680
 
    """Base class for use with transport backed storage.
681
 
 
682
 
    This provides a map and unmap wrapper that respectively url escape and
683
 
    unescape their outputs and inputs.
684
 
    """
685
 
 
686
 
    def map(self, key):
687
 
        """See KeyMapper.map()."""
688
 
        return urllib.quote(self._map(key))
689
 
 
690
 
    def unmap(self, partition_id):
691
 
        """See KeyMapper.unmap()."""
692
 
        return self._unmap(urllib.unquote(partition_id))
693
 
 
694
 
 
695
 
class PrefixMapper(URLEscapeMapper):
696
 
    """A key mapper that extracts the first component of a key.
697
 
 
698
 
    This mapper is for use with a transport based backend.
699
 
    """
700
 
 
701
 
    def _map(self, key):
702
 
        """See KeyMapper.map()."""
703
 
        return key[0]
704
 
 
705
 
    def _unmap(self, partition_id):
706
 
        """See KeyMapper.unmap()."""
707
 
        return (partition_id,)
708
 
 
709
 
 
710
 
class HashPrefixMapper(URLEscapeMapper):
711
 
    """A key mapper that combines the first component of a key with a hash.
712
 
 
713
 
    This mapper is for use with a transport based backend.
714
 
    """
715
 
 
716
 
    def _map(self, key):
717
 
        """See KeyMapper.map()."""
718
 
        prefix = self._escape(key[0])
719
 
        return "%02x/%s" % (adler32(prefix) & 0xff, prefix)
720
 
 
721
 
    def _escape(self, prefix):
722
 
        """No escaping needed here."""
723
 
        return prefix
724
 
 
725
 
    def _unmap(self, partition_id):
726
 
        """See KeyMapper.unmap()."""
727
 
        return (self._unescape(osutils.basename(partition_id)),)
728
 
 
729
 
    def _unescape(self, basename):
730
 
        """No unescaping needed for HashPrefixMapper."""
731
 
        return basename
732
 
 
733
 
 
734
 
class HashEscapedPrefixMapper(HashPrefixMapper):
735
 
    """Combines the escaped first component of a key with a hash.
736
 
 
737
 
    This mapper is for use with a transport based backend.
738
 
    """
739
 
 
740
 
    _safe = "abcdefghijklmnopqrstuvwxyz0123456789-_@,."
741
 
 
742
 
    def _escape(self, prefix):
743
 
        """Turn a key element into a filesystem safe string.
744
 
 
745
 
        This is similar to a plain urllib.quote, except
746
 
        it uses specific safe characters, so that it doesn't
747
 
        have to translate a lot of valid file ids.
748
 
        """
749
 
        # @ does not get escaped. This is because it is a valid
750
 
        # filesystem character we use all the time, and it looks
751
 
        # a lot better than seeing %40 all the time.
752
 
        r = [((c in self._safe) and c or ('%%%02x' % ord(c)))
753
 
             for c in prefix]
754
 
        return ''.join(r)
755
 
 
756
 
    def _unescape(self, basename):
757
 
        """Escaped names are easily unescaped by urlutils."""
758
 
        return urllib.unquote(basename)
759
 
 
760
 
 
761
 
def make_versioned_files_factory(versioned_file_factory, mapper):
762
 
    """Create a ThunkedVersionedFiles factory.
763
 
 
764
 
    This will create a callable which when called creates a
765
 
    ThunkedVersionedFiles on a transport, using mapper to access individual
766
 
    versioned files, and versioned_file_factory to create each individual file.
767
 
    """
768
 
    def factory(transport):
769
 
        return ThunkedVersionedFiles(transport, versioned_file_factory, mapper,
770
 
            lambda:True)
771
 
    return factory
772
 
 
773
 
 
774
 
class VersionedFiles(object):
775
 
    """Storage for many versioned files.
776
 
 
777
 
    This object allows a single keyspace for accessing the history graph and
778
 
    contents of named bytestrings.
779
 
 
780
 
    Currently no implementation allows the graph of different key prefixes to
781
 
    intersect, but the API does allow such implementations in the future.
782
 
 
783
 
    The keyspace is expressed via simple tuples. Any instance of VersionedFiles
784
 
    may have a different length key-size, but that size will be constant for
785
 
    all texts added to or retrieved from it. For instance, bzrlib uses
786
 
    instances with a key-size of 2 for storing user files in a repository, with
787
 
    the first element the fileid, and the second the version of that file.
788
 
 
789
 
    The use of tuples allows a single code base to support several different
790
 
    uses with only the mapping logic changing from instance to instance.
791
 
    """
792
 
 
793
 
    def add_lines(self, key, parents, lines, parent_texts=None,
794
 
        left_matching_blocks=None, nostore_sha=None, random_id=False,
795
 
        check_content=True):
796
 
        """Add a text to the store.
797
 
 
798
 
        :param key: The key tuple of the text to add. If the last element is
799
 
            None, a CHK string will be generated during the addition.
800
 
        :param parents: The parents key tuples of the text to add.
801
 
        :param lines: A list of lines. Each line must be a bytestring. And all
802
 
            of them except the last must be terminated with \n and contain no
803
 
            other \n's. The last line may either contain no \n's or a single
804
 
            terminating \n. If the lines list does meet this constraint the add
805
 
            routine may error or may succeed - but you will be unable to read
806
 
            the data back accurately. (Checking the lines have been split
807
 
            correctly is expensive and extremely unlikely to catch bugs so it
808
 
            is not done at runtime unless check_content is True.)
809
 
        :param parent_texts: An optional dictionary containing the opaque
810
 
            representations of some or all of the parents of version_id to
811
 
            allow delta optimisations.  VERY IMPORTANT: the texts must be those
812
 
            returned by add_lines or data corruption can be caused.
813
 
        :param left_matching_blocks: a hint about which areas are common
814
 
            between the text and its left-hand-parent.  The format is
815
 
            the SequenceMatcher.get_matching_blocks format.
816
 
        :param nostore_sha: Raise ExistingContent and do not add the lines to
817
 
            the versioned file if the digest of the lines matches this.
818
 
        :param random_id: If True a random id has been selected rather than
819
 
            an id determined by some deterministic process such as a converter
820
 
            from a foreign VCS. When True the backend may choose not to check
821
 
            for uniqueness of the resulting key within the versioned file, so
822
 
            this should only be done when the result is expected to be unique
823
 
            anyway.
824
 
        :param check_content: If True, the lines supplied are verified to be
825
 
            bytestrings that are correctly formed lines.
826
 
        :return: The text sha1, the number of bytes in the text, and an opaque
827
 
                 representation of the inserted version which can be provided
828
 
                 back to future add_lines calls in the parent_texts dictionary.
829
 
        """
830
 
        raise NotImplementedError(self.add_lines)
831
 
 
832
 
    def add_mpdiffs(self, records):
833
 
        """Add mpdiffs to this VersionedFile.
834
 
 
835
 
        Records should be iterables of version, parents, expected_sha1,
836
 
        mpdiff. mpdiff should be a MultiParent instance.
837
 
        """
838
 
        vf_parents = {}
839
 
        mpvf = multiparent.MultiMemoryVersionedFile()
840
 
        versions = []
841
 
        for version, parent_ids, expected_sha1, mpdiff in records:
842
 
            versions.append(version)
843
 
            mpvf.add_diff(mpdiff, version, parent_ids)
844
 
        needed_parents = set()
845
 
        for version, parent_ids, expected_sha1, mpdiff in records:
846
 
            needed_parents.update(p for p in parent_ids
847
 
                                  if not mpvf.has_version(p))
848
 
        # It seems likely that adding all the present parents as fulltexts can
849
 
        # easily exhaust memory.
850
 
        chunks_to_lines = osutils.chunks_to_lines
851
 
        for record in self.get_record_stream(needed_parents, 'unordered',
852
 
            True):
853
 
            if record.storage_kind == 'absent':
854
 
                continue
855
 
            mpvf.add_version(chunks_to_lines(record.get_bytes_as('chunked')),
856
 
                record.key, [])
857
 
        for (key, parent_keys, expected_sha1, mpdiff), lines in\
858
 
            zip(records, mpvf.get_line_list(versions)):
859
 
            if len(parent_keys) == 1:
860
 
                left_matching_blocks = list(mpdiff.get_matching_blocks(0,
861
 
                    mpvf.get_diff(parent_keys[0]).num_lines()))
862
 
            else:
863
 
                left_matching_blocks = None
864
 
            version_sha1, _, version_text = self.add_lines(key,
865
 
                parent_keys, lines, vf_parents,
866
 
                left_matching_blocks=left_matching_blocks)
867
 
            if version_sha1 != expected_sha1:
868
 
                raise errors.VersionedFileInvalidChecksum(version)
869
 
            vf_parents[key] = version_text
870
 
 
871
 
    def annotate(self, key):
872
 
        """Return a list of (version-key, line) tuples for the text of key.
873
 
 
874
 
        :raise RevisionNotPresent: If the key is not present.
875
 
        """
876
 
        raise NotImplementedError(self.annotate)
877
 
 
878
 
    def check(self, progress_bar=None):
879
 
        """Check this object for integrity."""
880
 
        raise NotImplementedError(self.check)
881
 
 
882
 
    @staticmethod
883
 
    def check_not_reserved_id(version_id):
884
 
        revision.check_not_reserved_id(version_id)
885
 
 
886
 
    def _check_lines_not_unicode(self, lines):
887
 
        """Check that lines being added to a versioned file are not unicode."""
888
 
        for line in lines:
889
 
            if line.__class__ is not str:
890
 
                raise errors.BzrBadParameterUnicode("lines")
891
 
 
892
 
    def _check_lines_are_lines(self, lines):
893
 
        """Check that the lines really are full lines without inline EOL."""
894
 
        for line in lines:
895
 
            if '\n' in line[:-1]:
896
 
                raise errors.BzrBadParameterContainsNewline("lines")
897
 
 
898
 
    def get_parent_map(self, keys):
899
 
        """Get a map of the parents of keys.
900
 
 
901
 
        :param keys: The keys to look up parents for.
902
 
        :return: A mapping from keys to parents. Absent keys are absent from
903
 
            the mapping.
904
 
        """
905
 
        raise NotImplementedError(self.get_parent_map)
906
 
 
907
 
    def get_record_stream(self, keys, ordering, include_delta_closure):
908
 
        """Get a stream of records for keys.
909
 
 
910
 
        :param keys: The keys to include.
911
 
        :param ordering: Either 'unordered' or 'topological'. A topologically
912
 
            sorted stream has compression parents strictly before their
913
 
            children.
914
 
        :param include_delta_closure: If True then the closure across any
915
 
            compression parents will be included (in the opaque data).
916
 
        :return: An iterator of ContentFactory objects, each of which is only
917
 
            valid until the iterator is advanced.
918
 
        """
919
 
        raise NotImplementedError(self.get_record_stream)
920
 
 
921
 
    def get_sha1s(self, keys):
922
 
        """Get the sha1's of the texts for the given keys.
923
 
 
924
 
        :param keys: The names of the keys to lookup
925
 
        :return: a dict from key to sha1 digest. Keys of texts which are not
926
 
            present in the store are not present in the returned
927
 
            dictionary.
928
 
        """
929
 
        raise NotImplementedError(self.get_sha1s)
930
 
 
931
 
    has_key = index._has_key_from_parent_map
932
 
 
933
 
    def get_missing_compression_parent_keys(self):
934
 
        """Return an iterable of keys of missing compression parents.
935
 
 
936
 
        Check this after calling insert_record_stream to find out if there are
937
 
        any missing compression parents.  If there are, the records that
938
 
        depend on them are not able to be inserted safely. The precise
939
 
        behaviour depends on the concrete VersionedFiles class in use.
940
 
 
941
 
        Classes that do not support this will raise NotImplementedError.
942
 
        """
943
 
        raise NotImplementedError(self.get_missing_compression_parent_keys)
944
 
 
945
 
    def insert_record_stream(self, stream):
946
 
        """Insert a record stream into this container.
947
 
 
948
 
        :param stream: A stream of records to insert.
949
 
        :return: None
950
 
        :seealso VersionedFile.get_record_stream:
951
 
        """
952
 
        raise NotImplementedError
953
 
 
954
 
    def iter_lines_added_or_present_in_keys(self, keys, pb=None):
955
 
        """Iterate over the lines in the versioned files from keys.
956
 
 
957
 
        This may return lines from other keys. Each item the returned
958
 
        iterator yields is a tuple of a line and a text version that that line
959
 
        is present in (not introduced in).
960
 
 
961
 
        Ordering of results is in whatever order is most suitable for the
962
 
        underlying storage format.
963
 
 
964
 
        If a progress bar is supplied, it may be used to indicate progress.
965
 
        The caller is responsible for cleaning up progress bars (because this
966
 
        is an iterator).
967
 
 
968
 
        NOTES:
969
 
         * Lines are normalised by the underlying store: they will all have \n
970
 
           terminators.
971
 
         * Lines are returned in arbitrary order.
972
 
 
973
 
        :return: An iterator over (line, key).
974
 
        """
975
 
        raise NotImplementedError(self.iter_lines_added_or_present_in_keys)
976
 
 
977
 
    def keys(self):
978
 
        """Return a iterable of the keys for all the contained texts."""
979
 
        raise NotImplementedError(self.keys)
980
 
 
981
 
    def make_mpdiffs(self, keys):
982
 
        """Create multiparent diffs for specified keys."""
983
 
        keys_order = tuple(keys)
984
 
        keys = frozenset(keys)
985
 
        knit_keys = set(keys)
986
 
        parent_map = self.get_parent_map(keys)
987
 
        for parent_keys in parent_map.itervalues():
988
 
            if parent_keys:
989
 
                knit_keys.update(parent_keys)
990
 
        missing_keys = keys - set(parent_map)
991
 
        if missing_keys:
992
 
            raise errors.RevisionNotPresent(list(missing_keys)[0], self)
993
 
        # We need to filter out ghosts, because we can't diff against them.
994
 
        maybe_ghosts = knit_keys - keys
995
 
        ghosts = maybe_ghosts - set(self.get_parent_map(maybe_ghosts))
996
 
        knit_keys.difference_update(ghosts)
997
 
        lines = {}
998
 
        chunks_to_lines = osutils.chunks_to_lines
999
 
        for record in self.get_record_stream(knit_keys, 'topological', True):
1000
 
            lines[record.key] = chunks_to_lines(record.get_bytes_as('chunked'))
1001
 
            # line_block_dict = {}
1002
 
            # for parent, blocks in record.extract_line_blocks():
1003
 
            #   line_blocks[parent] = blocks
1004
 
            # line_blocks[record.key] = line_block_dict
1005
 
        diffs = []
1006
 
        for key in keys_order:
1007
 
            target = lines[key]
1008
 
            parents = parent_map[key] or []
1009
 
            # Note that filtering knit_keys can lead to a parent difference
1010
 
            # between the creation and the application of the mpdiff.
1011
 
            parent_lines = [lines[p] for p in parents if p in knit_keys]
1012
 
            if len(parent_lines) > 0:
1013
 
                left_parent_blocks = self._extract_blocks(key, parent_lines[0],
1014
 
                    target)
1015
 
            else:
1016
 
                left_parent_blocks = None
1017
 
            diffs.append(multiparent.MultiParent.from_lines(target,
1018
 
                parent_lines, left_parent_blocks))
1019
 
        return diffs
1020
 
 
1021
 
    missing_keys = index._missing_keys_from_parent_map
1022
 
 
1023
 
    def _extract_blocks(self, version_id, source, target):
1024
 
        return None
1025
 
 
1026
 
 
1027
 
class ThunkedVersionedFiles(VersionedFiles):
1028
 
    """Storage for many versioned files thunked onto a 'VersionedFile' class.
1029
 
 
1030
 
    This object allows a single keyspace for accessing the history graph and
1031
 
    contents of named bytestrings.
1032
 
 
1033
 
    Currently no implementation allows the graph of different key prefixes to
1034
 
    intersect, but the API does allow such implementations in the future.
1035
 
    """
1036
 
 
1037
 
    def __init__(self, transport, file_factory, mapper, is_locked):
1038
 
        """Create a ThunkedVersionedFiles."""
1039
 
        self._transport = transport
1040
 
        self._file_factory = file_factory
1041
 
        self._mapper = mapper
1042
 
        self._is_locked = is_locked
1043
 
 
1044
 
    def add_lines(self, key, parents, lines, parent_texts=None,
1045
 
        left_matching_blocks=None, nostore_sha=None, random_id=False,
1046
 
        check_content=True):
1047
 
        """See VersionedFiles.add_lines()."""
1048
 
        path = self._mapper.map(key)
1049
 
        version_id = key[-1]
1050
 
        parents = [parent[-1] for parent in parents]
1051
 
        vf = self._get_vf(path)
1052
 
        try:
1053
 
            try:
1054
 
                return vf.add_lines_with_ghosts(version_id, parents, lines,
1055
 
                    parent_texts=parent_texts,
1056
 
                    left_matching_blocks=left_matching_blocks,
1057
 
                    nostore_sha=nostore_sha, random_id=random_id,
1058
 
                    check_content=check_content)
1059
 
            except NotImplementedError:
1060
 
                return vf.add_lines(version_id, parents, lines,
1061
 
                    parent_texts=parent_texts,
1062
 
                    left_matching_blocks=left_matching_blocks,
1063
 
                    nostore_sha=nostore_sha, random_id=random_id,
1064
 
                    check_content=check_content)
1065
 
        except errors.NoSuchFile:
1066
 
            # parent directory may be missing, try again.
1067
 
            self._transport.mkdir(osutils.dirname(path))
1068
 
            try:
1069
 
                return vf.add_lines_with_ghosts(version_id, parents, lines,
1070
 
                    parent_texts=parent_texts,
1071
 
                    left_matching_blocks=left_matching_blocks,
1072
 
                    nostore_sha=nostore_sha, random_id=random_id,
1073
 
                    check_content=check_content)
1074
 
            except NotImplementedError:
1075
 
                return vf.add_lines(version_id, parents, lines,
1076
 
                    parent_texts=parent_texts,
1077
 
                    left_matching_blocks=left_matching_blocks,
1078
 
                    nostore_sha=nostore_sha, random_id=random_id,
1079
 
                    check_content=check_content)
1080
 
 
1081
 
    def annotate(self, key):
1082
 
        """Return a list of (version-key, line) tuples for the text of key.
1083
 
 
1084
 
        :raise RevisionNotPresent: If the key is not present.
1085
 
        """
1086
 
        prefix = key[:-1]
1087
 
        path = self._mapper.map(prefix)
1088
 
        vf = self._get_vf(path)
1089
 
        origins = vf.annotate(key[-1])
1090
 
        result = []
1091
 
        for origin, line in origins:
1092
 
            result.append((prefix + (origin,), line))
1093
 
        return result
1094
 
 
1095
 
    def check(self, progress_bar=None):
1096
 
        """See VersionedFiles.check()."""
1097
 
        for prefix, vf in self._iter_all_components():
1098
 
            vf.check()
1099
 
 
1100
 
    def get_parent_map(self, keys):
1101
 
        """Get a map of the parents of keys.
1102
 
 
1103
 
        :param keys: The keys to look up parents for.
1104
 
        :return: A mapping from keys to parents. Absent keys are absent from
1105
 
            the mapping.
1106
 
        """
1107
 
        prefixes = self._partition_keys(keys)
1108
 
        result = {}
1109
 
        for prefix, suffixes in prefixes.items():
1110
 
            path = self._mapper.map(prefix)
1111
 
            vf = self._get_vf(path)
1112
 
            parent_map = vf.get_parent_map(suffixes)
1113
 
            for key, parents in parent_map.items():
1114
 
                result[prefix + (key,)] = tuple(
1115
 
                    prefix + (parent,) for parent in parents)
1116
 
        return result
1117
 
 
1118
 
    def _get_vf(self, path):
1119
 
        if not self._is_locked():
1120
 
            raise errors.ObjectNotLocked(self)
1121
 
        return self._file_factory(path, self._transport, create=True,
1122
 
            get_scope=lambda:None)
1123
 
 
1124
 
    def _partition_keys(self, keys):
1125
 
        """Turn keys into a dict of prefix:suffix_list."""
1126
 
        result = {}
1127
 
        for key in keys:
1128
 
            prefix_keys = result.setdefault(key[:-1], [])
1129
 
            prefix_keys.append(key[-1])
1130
 
        return result
1131
 
 
1132
 
    def _get_all_prefixes(self):
1133
 
        # Identify all key prefixes.
1134
 
        # XXX: A bit hacky, needs polish.
1135
 
        if type(self._mapper) == ConstantMapper:
1136
 
            paths = [self._mapper.map(())]
1137
 
            prefixes = [()]
1138
 
        else:
1139
 
            relpaths = set()
1140
 
            for quoted_relpath in self._transport.iter_files_recursive():
1141
 
                path, ext = os.path.splitext(quoted_relpath)
1142
 
                relpaths.add(path)
1143
 
            paths = list(relpaths)
1144
 
            prefixes = [self._mapper.unmap(path) for path in paths]
1145
 
        return zip(paths, prefixes)
1146
 
 
1147
 
    def get_record_stream(self, keys, ordering, include_delta_closure):
1148
 
        """See VersionedFiles.get_record_stream()."""
1149
 
        # Ordering will be taken care of by each partitioned store; group keys
1150
 
        # by partition.
1151
 
        keys = sorted(keys)
1152
 
        for prefix, suffixes, vf in self._iter_keys_vf(keys):
1153
 
            suffixes = [(suffix,) for suffix in suffixes]
1154
 
            for record in vf.get_record_stream(suffixes, ordering,
1155
 
                include_delta_closure):
1156
 
                if record.parents is not None:
1157
 
                    record.parents = tuple(
1158
 
                        prefix + parent for parent in record.parents)
1159
 
                record.key = prefix + record.key
1160
 
                yield record
1161
 
 
1162
 
    def _iter_keys_vf(self, keys):
1163
 
        prefixes = self._partition_keys(keys)
1164
 
        sha1s = {}
1165
 
        for prefix, suffixes in prefixes.items():
1166
 
            path = self._mapper.map(prefix)
1167
 
            vf = self._get_vf(path)
1168
 
            yield prefix, suffixes, vf
1169
 
 
1170
 
    def get_sha1s(self, keys):
1171
 
        """See VersionedFiles.get_sha1s()."""
1172
 
        sha1s = {}
1173
 
        for prefix,suffixes, vf in self._iter_keys_vf(keys):
1174
 
            vf_sha1s = vf.get_sha1s(suffixes)
1175
 
            for suffix, sha1 in vf_sha1s.iteritems():
1176
 
                sha1s[prefix + (suffix,)] = sha1
1177
 
        return sha1s
1178
 
 
1179
 
    def insert_record_stream(self, stream):
1180
 
        """Insert a record stream into this container.
1181
 
 
1182
 
        :param stream: A stream of records to insert.
1183
 
        :return: None
1184
 
        :seealso VersionedFile.get_record_stream:
1185
 
        """
1186
 
        for record in stream:
1187
 
            prefix = record.key[:-1]
1188
 
            key = record.key[-1:]
1189
 
            if record.parents is not None:
1190
 
                parents = [parent[-1:] for parent in record.parents]
1191
 
            else:
1192
 
                parents = None
1193
 
            thunk_record = AdapterFactory(key, parents, record)
1194
 
            path = self._mapper.map(prefix)
1195
 
            # Note that this parses the file many times; we can do better but
1196
 
            # as this only impacts weaves in terms of performance, it is
1197
 
            # tolerable.
1198
 
            vf = self._get_vf(path)
1199
 
            vf.insert_record_stream([thunk_record])
1200
 
 
1201
 
    def iter_lines_added_or_present_in_keys(self, keys, pb=None):
1202
 
        """Iterate over the lines in the versioned files from keys.
1203
 
 
1204
 
        This may return lines from other keys. Each item the returned
1205
 
        iterator yields is a tuple of a line and a text version that that line
1206
 
        is present in (not introduced in).
1207
 
 
1208
 
        Ordering of results is in whatever order is most suitable for the
1209
 
        underlying storage format.
1210
 
 
1211
 
        If a progress bar is supplied, it may be used to indicate progress.
1212
 
        The caller is responsible for cleaning up progress bars (because this
1213
 
        is an iterator).
1214
 
 
1215
 
        NOTES:
1216
 
         * Lines are normalised by the underlying store: they will all have \n
1217
 
           terminators.
1218
 
         * Lines are returned in arbitrary order.
1219
 
 
1220
 
        :return: An iterator over (line, key).
1221
 
        """
1222
 
        for prefix, suffixes, vf in self._iter_keys_vf(keys):
1223
 
            for line, version in vf.iter_lines_added_or_present_in_versions(suffixes):
1224
 
                yield line, prefix + (version,)
1225
 
 
1226
 
    def _iter_all_components(self):
1227
 
        for path, prefix in self._get_all_prefixes():
1228
 
            yield prefix, self._get_vf(path)
1229
 
 
1230
 
    def keys(self):
1231
 
        """See VersionedFiles.keys()."""
1232
 
        result = set()
1233
 
        for prefix, vf in self._iter_all_components():
1234
 
            for suffix in vf.versions():
1235
 
                result.add(prefix + (suffix,))
1236
 
        return result
1237
 
 
1238
 
 
1239
 
class _PlanMergeVersionedFile(VersionedFiles):
 
495
class _PlanMergeVersionedFile(object):
1240
496
    """A VersionedFile for uncommitted and committed texts.
1241
497
 
1242
498
    It is intended to allow merges to be planned with working tree texts.
1243
 
    It implements only the small part of the VersionedFiles interface used by
 
499
    It implements only the small part of the VersionedFile interface used by
1244
500
    PlanMerge.  It falls back to multiple versionedfiles for data not stored in
1245
501
    _PlanMergeVersionedFile itself.
1246
 
 
1247
 
    :ivar: fallback_versionedfiles a list of VersionedFiles objects that can be
1248
 
        queried for missing texts.
1249
502
    """
1250
503
 
1251
 
    def __init__(self, file_id):
1252
 
        """Create a _PlanMergeVersionedFile.
 
504
    def __init__(self, file_id, fallback_versionedfiles=None):
 
505
        """Constuctor
1253
506
 
1254
 
        :param file_id: Used with _PlanMerge code which is not yet fully
1255
 
            tuple-keyspace aware.
 
507
        :param file_id: Used when raising exceptions.
 
508
        :param fallback_versionedfiles: If supplied, the set of fallbacks to
 
509
            use.  Otherwise, _PlanMergeVersionedFile.fallback_versionedfiles
 
510
            can be appended to later.
1256
511
        """
1257
512
        self._file_id = file_id
1258
 
        # fallback locations
1259
 
        self.fallback_versionedfiles = []
1260
 
        # Parents for locally held keys.
 
513
        if fallback_versionedfiles is None:
 
514
            self.fallback_versionedfiles = []
 
515
        else:
 
516
            self.fallback_versionedfiles = fallback_versionedfiles
1261
517
        self._parents = {}
1262
 
        # line data for locally held keys.
1263
518
        self._lines = {}
1264
 
        # key lookup providers
1265
 
        self._providers = [DictParentsProvider(self._parents)]
1266
519
 
1267
520
    def plan_merge(self, ver_a, ver_b, base=None):
1268
521
        """See VersionedFile.plan_merge"""
1269
522
        from bzrlib.merge import _PlanMerge
1270
523
        if base is None:
1271
 
            return _PlanMerge(ver_a, ver_b, self, (self._file_id,)).plan_merge()
1272
 
        old_plan = list(_PlanMerge(ver_a, base, self, (self._file_id,)).plan_merge())
1273
 
        new_plan = list(_PlanMerge(ver_a, ver_b, self, (self._file_id,)).plan_merge())
 
524
            return _PlanMerge(ver_a, ver_b, self).plan_merge()
 
525
        old_plan = list(_PlanMerge(ver_a, base, self).plan_merge())
 
526
        new_plan = list(_PlanMerge(ver_a, ver_b, self).plan_merge())
1274
527
        return _PlanMerge._subtract_plans(old_plan, new_plan)
1275
528
 
1276
529
    def plan_lca_merge(self, ver_a, ver_b, base=None):
1277
530
        from bzrlib.merge import _PlanLCAMerge
1278
 
        graph = Graph(self)
1279
 
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, (self._file_id,), graph).plan_merge()
 
531
        graph = self._get_graph()
 
532
        new_plan = _PlanLCAMerge(ver_a, ver_b, self, graph).plan_merge()
1280
533
        if base is None:
1281
534
            return new_plan
1282
 
        old_plan = _PlanLCAMerge(ver_a, base, self, (self._file_id,), graph).plan_merge()
 
535
        old_plan = _PlanLCAMerge(ver_a, base, self, graph).plan_merge()
1283
536
        return _PlanLCAMerge._subtract_plans(list(old_plan), list(new_plan))
1284
537
 
1285
 
    def add_lines(self, key, parents, lines):
1286
 
        """See VersionedFiles.add_lines
 
538
    def add_lines(self, version_id, parents, lines):
 
539
        """See VersionedFile.add_lines
1287
540
 
1288
 
        Lines are added locally, not to fallback versionedfiles.  Also, ghosts
1289
 
        are permitted.  Only reserved ids are permitted.
 
541
        Lines are added locally, not fallback versionedfiles.  Also, ghosts are
 
542
        permitted.  Only reserved ids are permitted.
1290
543
        """
1291
 
        if type(key) is not tuple:
1292
 
            raise TypeError(key)
1293
 
        if not revision.is_reserved_id(key[-1]):
 
544
        if not revision.is_reserved_id(version_id):
1294
545
            raise ValueError('Only reserved ids may be used')
1295
546
        if parents is None:
1296
547
            raise ValueError('Parents may not be None')
1297
548
        if lines is None:
1298
549
            raise ValueError('Lines may not be None')
1299
 
        self._parents[key] = tuple(parents)
1300
 
        self._lines[key] = lines
 
550
        self._parents[version_id] = parents
 
551
        self._lines[version_id] = lines
1301
552
 
1302
 
    def get_record_stream(self, keys, ordering, include_delta_closure):
1303
 
        pending = set(keys)
1304
 
        for key in keys:
1305
 
            if key in self._lines:
1306
 
                lines = self._lines[key]
1307
 
                parents = self._parents[key]
1308
 
                pending.remove(key)
1309
 
                yield ChunkedContentFactory(key, parents, None, lines)
 
553
    def get_lines(self, version_id):
 
554
        """See VersionedFile.get_ancestry"""
 
555
        lines = self._lines.get(version_id)
 
556
        if lines is not None:
 
557
            return lines
1310
558
        for versionedfile in self.fallback_versionedfiles:
1311
 
            for record in versionedfile.get_record_stream(
1312
 
                pending, 'unordered', True):
1313
 
                if record.storage_kind == 'absent':
 
559
            try:
 
560
                return versionedfile.get_lines(version_id)
 
561
            except errors.RevisionNotPresent:
 
562
                continue
 
563
        else:
 
564
            raise errors.RevisionNotPresent(version_id, self._file_id)
 
565
 
 
566
    def get_ancestry(self, version_id, topo_sorted=False):
 
567
        """See VersionedFile.get_ancestry.
 
568
 
 
569
        Note that this implementation assumes that if a VersionedFile can
 
570
        answer get_ancestry at all, it can give an authoritative answer.  In
 
571
        fact, ghosts can invalidate this assumption.  But it's good enough
 
572
        99% of the time, and far cheaper/simpler.
 
573
 
 
574
        Also note that the results of this version are never topologically
 
575
        sorted, and are a set.
 
576
        """
 
577
        if topo_sorted:
 
578
            raise ValueError('This implementation does not provide sorting')
 
579
        parents = self._parents.get(version_id)
 
580
        if parents is None:
 
581
            for vf in self.fallback_versionedfiles:
 
582
                try:
 
583
                    return vf.get_ancestry(version_id, topo_sorted=False)
 
584
                except errors.RevisionNotPresent:
1314
585
                    continue
1315
 
                else:
1316
 
                    pending.remove(record.key)
1317
 
                    yield record
1318
 
            if not pending:
1319
 
                return
1320
 
        # report absent entries
1321
 
        for key in pending:
1322
 
            yield AbsentContentFactory(key)
1323
 
 
1324
 
    def get_parent_map(self, keys):
1325
 
        """See VersionedFiles.get_parent_map"""
1326
 
        # We create a new provider because a fallback may have been added.
1327
 
        # If we make fallbacks private we can update a stack list and avoid
1328
 
        # object creation thrashing.
1329
 
        keys = set(keys)
1330
 
        result = {}
1331
 
        if revision.NULL_REVISION in keys:
1332
 
            keys.remove(revision.NULL_REVISION)
1333
 
            result[revision.NULL_REVISION] = ()
1334
 
        self._providers = self._providers[:1] + self.fallback_versionedfiles
1335
 
        result.update(
1336
 
            _StackedParentsProvider(self._providers).get_parent_map(keys))
1337
 
        for key, parents in result.iteritems():
1338
 
            if parents == ():
1339
 
                result[key] = (revision.NULL_REVISION,)
1340
 
        return result
 
586
            else:
 
587
                raise errors.RevisionNotPresent(version_id, self._file_id)
 
588
        ancestry = set([version_id])
 
589
        for parent in parents:
 
590
            ancestry.update(self.get_ancestry(parent, topo_sorted=False))
 
591
        return ancestry
 
592
 
 
593
    def get_parents(self, version_id):
 
594
        """See VersionedFile.get_parents"""
 
595
        parents = self._parents.get(version_id)
 
596
        if parents is not None:
 
597
            return parents
 
598
        for versionedfile in self.fallback_versionedfiles:
 
599
            try:
 
600
                return versionedfile.get_parents(version_id)
 
601
            except errors.RevisionNotPresent:
 
602
                continue
 
603
        else:
 
604
            raise errors.RevisionNotPresent(version_id, self._file_id)
 
605
 
 
606
    def _get_graph(self):
 
607
        from bzrlib.graph import (
 
608
            DictParentsProvider,
 
609
            Graph,
 
610
            _StackedParentsProvider,
 
611
            )
 
612
        from bzrlib.repofmt.knitrepo import _KnitParentsProvider
 
613
        parent_providers = [DictParentsProvider(self._parents)]
 
614
        for vf in self.fallback_versionedfiles:
 
615
            parent_providers.append(_KnitParentsProvider(vf))
 
616
        return Graph(_StackedParentsProvider(parent_providers))
1341
617
 
1342
618
 
1343
619
class PlanWeaveMerge(TextMerge):
1344
620
    """Weave merge that takes a plan as its input.
1345
 
 
 
621
    
1346
622
    This exists so that VersionedFile.plan_merge is implementable.
1347
623
    Most callers will want to use WeaveMerge instead.
1348
624
    """
1369
645
                yield(lines_a,)
1370
646
            else:
1371
647
                yield (lines_a, lines_b)
1372
 
 
 
648
       
1373
649
        # We previously considered either 'unchanged' or 'killed-both' lines
1374
650
        # to be possible places to resynchronize.  However, assuming agreement
1375
651
        # on killed-both lines may be too aggressive. -- mbp 20060324
1381
657
                lines_a = []
1382
658
                lines_b = []
1383
659
                ch_a = ch_b = False
1384
 
 
 
660
                
1385
661
            if state == 'unchanged':
1386
662
                if line:
1387
663
                    yield ([line],)
1403
679
            elif state == 'conflicted-b':
1404
680
                ch_b = ch_a = True
1405
681
                lines_b.append(line)
1406
 
            elif state == 'killed-both':
1407
 
                # This counts as a change, even though there is no associated
1408
 
                # line
1409
 
                ch_b = ch_a = True
1410
682
            else:
1411
 
                if state not in ('irrelevant', 'ghost-a', 'ghost-b',
1412
 
                        'killed-base'):
1413
 
                    raise AssertionError(state)
 
683
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 
 
684
                                 'killed-base', 'killed-both'), state
1414
685
        for struct in outstanding_struct():
1415
686
            yield struct
1416
687
 
1418
689
class WeaveMerge(PlanWeaveMerge):
1419
690
    """Weave merge that takes a VersionedFile and two versions as its input."""
1420
691
 
1421
 
    def __init__(self, versionedfile, ver_a, ver_b,
 
692
    def __init__(self, versionedfile, ver_a, ver_b, 
1422
693
        a_marker=PlanWeaveMerge.A_MARKER, b_marker=PlanWeaveMerge.B_MARKER):
1423
694
        plan = versionedfile.plan_merge(ver_a, ver_b)
1424
695
        PlanWeaveMerge.__init__(self, plan, a_marker, b_marker)
1425
696
 
1426
697
 
1427
 
class VirtualVersionedFiles(VersionedFiles):
1428
 
    """Dummy implementation for VersionedFiles that uses other functions for
1429
 
    obtaining fulltexts and parent maps.
1430
 
 
1431
 
    This is always on the bottom of the stack and uses string keys
1432
 
    (rather than tuples) internally.
1433
 
    """
1434
 
 
1435
 
    def __init__(self, get_parent_map, get_lines):
1436
 
        """Create a VirtualVersionedFiles.
1437
 
 
1438
 
        :param get_parent_map: Same signature as Repository.get_parent_map.
1439
 
        :param get_lines: Should return lines for specified key or None if
1440
 
                          not available.
1441
 
        """
1442
 
        super(VirtualVersionedFiles, self).__init__()
1443
 
        self._get_parent_map = get_parent_map
1444
 
        self._get_lines = get_lines
1445
 
 
1446
 
    def check(self, progressbar=None):
1447
 
        """See VersionedFiles.check.
1448
 
 
1449
 
        :note: Always returns True for VirtualVersionedFiles.
1450
 
        """
1451
 
        return True
1452
 
 
1453
 
    def add_mpdiffs(self, records):
1454
 
        """See VersionedFiles.mpdiffs.
1455
 
 
1456
 
        :note: Not implemented for VirtualVersionedFiles.
1457
 
        """
1458
 
        raise NotImplementedError(self.add_mpdiffs)
1459
 
 
1460
 
    def get_parent_map(self, keys):
1461
 
        """See VersionedFiles.get_parent_map."""
1462
 
        return dict([((k,), tuple([(p,) for p in v]))
1463
 
            for k,v in self._get_parent_map([k for (k,) in keys]).iteritems()])
1464
 
 
1465
 
    def get_sha1s(self, keys):
1466
 
        """See VersionedFiles.get_sha1s."""
1467
 
        ret = {}
1468
 
        for (k,) in keys:
1469
 
            lines = self._get_lines(k)
1470
 
            if lines is not None:
1471
 
                if not isinstance(lines, list):
1472
 
                    raise AssertionError
1473
 
                ret[(k,)] = osutils.sha_strings(lines)
1474
 
        return ret
1475
 
 
1476
 
    def get_record_stream(self, keys, ordering, include_delta_closure):
1477
 
        """See VersionedFiles.get_record_stream."""
1478
 
        for (k,) in list(keys):
1479
 
            lines = self._get_lines(k)
1480
 
            if lines is not None:
1481
 
                if not isinstance(lines, list):
1482
 
                    raise AssertionError
1483
 
                yield ChunkedContentFactory((k,), None,
1484
 
                        sha1=osutils.sha_strings(lines),
1485
 
                        chunks=lines)
1486
 
            else:
1487
 
                yield AbsentContentFactory((k,))
1488
 
 
1489
 
    def iter_lines_added_or_present_in_keys(self, keys, pb=None):
1490
 
        """See VersionedFile.iter_lines_added_or_present_in_versions()."""
1491
 
        for i, (key,) in enumerate(keys):
1492
 
            if pb is not None:
1493
 
                pb.update("Finding changed lines", i, len(keys))
1494
 
            for l in self._get_lines(key):
1495
 
                yield (l, key)
1496
 
 
1497
 
 
1498
 
def network_bytes_to_kind_and_offset(network_bytes):
1499
 
    """Strip of a record kind from the front of network_bytes.
1500
 
 
1501
 
    :param network_bytes: The bytes of a record.
1502
 
    :return: A tuple (storage_kind, offset_of_remaining_bytes)
1503
 
    """
1504
 
    line_end = network_bytes.find('\n')
1505
 
    storage_kind = network_bytes[:line_end]
1506
 
    return storage_kind, line_end + 1
1507
 
 
1508
 
 
1509
 
class NetworkRecordStream(object):
1510
 
    """A record_stream which reconstitures a serialised stream."""
1511
 
 
1512
 
    def __init__(self, bytes_iterator):
1513
 
        """Create a NetworkRecordStream.
1514
 
 
1515
 
        :param bytes_iterator: An iterator of bytes. Each item in this
1516
 
            iterator should have been obtained from a record_streams'
1517
 
            record.get_bytes_as(record.storage_kind) call.
1518
 
        """
1519
 
        self._bytes_iterator = bytes_iterator
1520
 
        self._kind_factory = {'knit-ft-gz':knit.knit_network_to_record,
1521
 
            'knit-delta-gz':knit.knit_network_to_record,
1522
 
            'knit-annotated-ft-gz':knit.knit_network_to_record,
1523
 
            'knit-annotated-delta-gz':knit.knit_network_to_record,
1524
 
            'knit-delta-closure':knit.knit_delta_closure_to_records,
1525
 
            'fulltext':fulltext_network_to_record,
1526
 
            'groupcompress-block':groupcompress.network_block_to_records,
1527
 
            }
1528
 
 
1529
 
    def read(self):
1530
 
        """Read the stream.
1531
 
 
1532
 
        :return: An iterator as per VersionedFiles.get_record_stream().
1533
 
        """
1534
 
        for bytes in self._bytes_iterator:
1535
 
            storage_kind, line_end = network_bytes_to_kind_and_offset(bytes)
1536
 
            for record in self._kind_factory[storage_kind](
1537
 
                storage_kind, bytes, line_end):
1538
 
                yield record
1539
 
 
1540
 
 
1541
 
def fulltext_network_to_record(kind, bytes, line_end):
1542
 
    """Convert a network fulltext record to record."""
1543
 
    meta_len, = struct.unpack('!L', bytes[line_end:line_end+4])
1544
 
    record_meta = bytes[line_end+4:line_end+4+meta_len]
1545
 
    key, parents = bencode.bdecode_as_tuple(record_meta)
1546
 
    if parents == 'nil':
1547
 
        parents = None
1548
 
    fulltext = bytes[line_end+4+meta_len:]
1549
 
    return [FulltextContentFactory(key, parents, None, fulltext)]
1550
 
 
1551
 
 
1552
 
def _length_prefix(bytes):
1553
 
    return struct.pack('!L', len(bytes))
1554
 
 
1555
 
 
1556
 
def record_to_fulltext_bytes(record):
1557
 
    if record.parents is None:
1558
 
        parents = 'nil'
1559
 
    else:
1560
 
        parents = record.parents
1561
 
    record_meta = bencode.bencode((record.key, parents))
1562
 
    record_content = record.get_bytes_as('fulltext')
1563
 
    return "fulltext\n%s%s%s" % (
1564
 
        _length_prefix(record_meta), record_meta, record_content)
1565
 
 
1566
 
 
1567
 
def sort_groupcompress(parent_map):
1568
 
    """Sort and group the keys in parent_map into groupcompress order.
1569
 
 
1570
 
    groupcompress is defined (currently) as reverse-topological order, grouped
1571
 
    by the key prefix.
1572
 
 
1573
 
    :return: A sorted-list of keys
1574
 
    """
1575
 
    # gc-optimal ordering is approximately reverse topological,
1576
 
    # properly grouped by file-id.
1577
 
    per_prefix_map = {}
1578
 
    for item in parent_map.iteritems():
1579
 
        key = item[0]
1580
 
        if isinstance(key, str) or len(key) == 1:
1581
 
            prefix = ''
 
698
class InterVersionedFile(InterObject):
 
699
    """This class represents operations taking place between two VersionedFiles.
 
700
 
 
701
    Its instances have methods like join, and contain
 
702
    references to the source and target versionedfiles these operations can be 
 
703
    carried out on.
 
704
 
 
705
    Often we will provide convenience methods on 'versionedfile' which carry out
 
706
    operations with another versionedfile - they will always forward to
 
707
    InterVersionedFile.get(other).method_name(parameters).
 
708
    """
 
709
 
 
710
    _optimisers = []
 
711
    """The available optimised InterVersionedFile types."""
 
712
 
 
713
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
 
714
        """Integrate versions from self.source into self.target.
 
715
 
 
716
        If version_ids is None all versions from source should be
 
717
        incorporated into this versioned file.
 
718
 
 
719
        Must raise RevisionNotPresent if any of the specified versions
 
720
        are not present in the other file's history unless ignore_missing is 
 
721
        supplied in which case they are silently skipped.
 
722
        """
 
723
        # the default join: 
 
724
        # - if the target is empty, just add all the versions from 
 
725
        #   source to target, otherwise:
 
726
        # - make a temporary versioned file of type target
 
727
        # - insert the source content into it one at a time
 
728
        # - join them
 
729
        if not self.target.versions():
 
730
            target = self.target
1582
731
        else:
1583
 
            prefix = key[0]
 
732
            # Make a new target-format versioned file. 
 
733
            temp_source = self.target.create_empty("temp", MemoryTransport())
 
734
            target = temp_source
 
735
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
 
736
        graph = self.source.get_graph(version_ids)
 
737
        order = tsort.topo_sort(graph.items())
 
738
        pb = ui.ui_factory.nested_progress_bar()
 
739
        parent_texts = {}
1584
740
        try:
1585
 
            per_prefix_map[prefix].append(item)
1586
 
        except KeyError:
1587
 
            per_prefix_map[prefix] = [item]
1588
 
 
1589
 
    present_keys = []
1590
 
    for prefix in sorted(per_prefix_map):
1591
 
        present_keys.extend(reversed(tsort.topo_sort(per_prefix_map[prefix])))
1592
 
    return present_keys
 
741
            # TODO for incremental cross-format work:
 
742
            # make a versioned file with the following content:
 
743
            # all revisions we have been asked to join
 
744
            # all their ancestors that are *not* in target already.
 
745
            # the immediate parents of the above two sets, with 
 
746
            # empty parent lists - these versions are in target already
 
747
            # and the incorrect version data will be ignored.
 
748
            # TODO: for all ancestors that are present in target already,
 
749
            # check them for consistent data, this requires moving sha1 from
 
750
            # 
 
751
            # TODO: remove parent texts when they are not relevant any more for 
 
752
            # memory pressure reduction. RBC 20060313
 
753
            # pb.update('Converting versioned data', 0, len(order))
 
754
            total = len(order)
 
755
            for index, version in enumerate(order):
 
756
                pb.update('Converting versioned data', index, total)
 
757
                _, _, parent_text = target.add_lines(version,
 
758
                                               self.source.get_parents(version),
 
759
                                               self.source.get_lines(version),
 
760
                                               parent_texts=parent_texts)
 
761
                parent_texts[version] = parent_text
 
762
            
 
763
            # this should hit the native code path for target
 
764
            if target is not self.target:
 
765
                return self.target.join(temp_source,
 
766
                                        pb,
 
767
                                        msg,
 
768
                                        version_ids,
 
769
                                        ignore_missing)
 
770
            else:
 
771
                return total
 
772
        finally:
 
773
            pb.finished()
 
774
 
 
775
    def _get_source_version_ids(self, version_ids, ignore_missing):
 
776
        """Determine the version ids to be used from self.source.
 
777
 
 
778
        :param version_ids: The caller-supplied version ids to check. (None 
 
779
                            for all). If None is in version_ids, it is stripped.
 
780
        :param ignore_missing: if True, remove missing ids from the version 
 
781
                               list. If False, raise RevisionNotPresent on
 
782
                               a missing version id.
 
783
        :return: A set of version ids.
 
784
        """
 
785
        if version_ids is None:
 
786
            # None cannot be in source.versions
 
787
            return set(self.source.versions())
 
788
        else:
 
789
            if ignore_missing:
 
790
                return set(self.source.versions()).intersection(set(version_ids))
 
791
            else:
 
792
                new_version_ids = set()
 
793
                for version in version_ids:
 
794
                    if version is None:
 
795
                        continue
 
796
                    if not self.source.has_version(version):
 
797
                        raise errors.RevisionNotPresent(version, str(self.source))
 
798
                    else:
 
799
                        new_version_ids.add(version)
 
800
                return new_version_ids