← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

  • Committer: Martin Pool
  • Date: 2005-09-20 08:06:24 UTC
  • Revision ID: mbp@sourcefrog.net-20050920080624-25bfe88297f9eaa2
- doc

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/weave.py
1
1
#! /usr/bin/python
2
2
 
3
3
# Copyright (C) 2005 Canonical Ltd
4
 
#
 
4
 
5
5
# This program is free software; you can redistribute it and/or modify
6
6
# it under the terms of the GNU General Public License as published by
7
7
# the Free Software Foundation; either version 2 of the License, or
8
8
# (at your option) any later version.
9
 
#
 
9
 
10
10
# This program is distributed in the hope that it will be useful,
11
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
12
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
13
# GNU General Public License for more details.
14
 
#
 
14
 
15
15
# You should have received a copy of the GNU General Public License
16
16
# along with this program; if not, write to the Free Software
17
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
21
 
22
22
"""Weave - storage of related text file versions"""
23
23
 
 
24
# before intset (r923) 2000 versions in 41.5s
 
25
# with intset (r926) 2000 versions in 93s !!!
 
26
# better to just use plain sets.
 
27
 
 
28
# making _extract build and return a list, rather than being a generator
 
29
# takes 37.94s
 
30
 
 
31
# with python -O, r923 does 2000 versions in 36.87s
 
32
 
 
33
# with optimizations to avoid mutating lists - 35.75!  I guess copying
 
34
# all the elements every time costs more than the small manipulations.
 
35
# a surprisingly small change.
 
36
 
 
37
# r931, which avoids using a generator for extract, does 36.98s
 
38
 
 
39
# with memoized inclusions, takes 41.49s; not very good
 
40
 
 
41
# with slots, takes 37.35s; without takes 39.16, a bit surprising
 
42
 
 
43
# with the delta calculation mixed in with the add method, rather than
 
44
# separated, takes 36.78s
 
45
 
 
46
# with delta folded in and mutation of the list, 36.13s
 
47
 
 
48
# with all this and simplification of add code, 33s
 
49
 
 
50
 
 
51
 
 
52
 
 
53
 
 
54
# TODO: Perhaps have copy method for Weave instances?
24
55
 
25
56
# XXX: If we do weaves this way, will a merge still behave the same
26
57
# way if it's done in a different order?  That's a pretty desirable
27
58
# property.
28
59
 
29
60
# TODO: Nothing here so far assumes the lines are really \n newlines,
30
 
# rather than being split up in some other way.  We could accommodate
 
61
# rather than being split up in some other way.  We could accomodate
31
62
# binaries, perhaps by naively splitting on \n or perhaps using
32
63
# something like a rolling checksum.
33
64
 
43
74
 
44
75
# TODO: Parallel-extract that passes back each line along with a
45
76
# description of which revisions include it.  Nice for checking all
46
 
# shas or calculating stats in parallel.
 
77
# shas in parallel.
47
78
 
48
79
# TODO: Using a single _extract routine and then processing the output
49
80
# is probably inefficient.  It's simple enough that we can afford to
50
81
# have slight specializations for different ways its used: annotate,
51
82
# basis for add, get, etc.
52
83
 
53
 
# TODO: Probably the API should work only in names to hide the integer
54
 
# indexes from the user.
 
84
# TODO: Perhaps the API should work only in names to hide the integer
 
85
# indexes from the user?
55
86
 
56
87
# TODO: Is there any potential performance win by having an add()
57
88
# variant that is passed a pre-cooked version of the single basis
58
89
# version?
59
90
 
60
 
# TODO: Reweave can possibly be made faster by remembering diffs
61
 
# where the basis and destination are unchanged.
62
 
 
63
 
# FIXME: Sometimes we will be given a parents list for a revision
64
 
# that includes some redundant parents (i.e. already a parent of 
65
 
# something in the list.)  We should eliminate them.  This can 
66
 
# be done fairly efficiently because the sequence numbers constrain
67
 
# the possible relationships.
68
 
 
69
 
# FIXME: the conflict markers should be *7* characters
70
 
 
71
 
from copy import copy
 
91
 
 
92
 
 
93
import sha
 
94
from difflib import SequenceMatcher
 
95
 
72
96
from cStringIO import StringIO
73
 
import os
74
 
import sha
75
 
import time
76
 
import warnings
77
97
 
78
 
from bzrlib import (
79
 
    progress,
80
 
    )
81
 
from bzrlib.trace import mutter
82
 
from bzrlib.errors import (WeaveError, WeaveFormatError, WeaveParentMismatch,
83
 
        RevisionAlreadyPresent,
84
 
        RevisionNotPresent,
85
 
        WeaveRevisionAlreadyPresent,
86
 
        WeaveRevisionNotPresent,
87
 
        )
88
 
import bzrlib.errors as errors
89
98
from bzrlib.osutils import sha_strings
90
 
import bzrlib.patiencediff
91
 
from bzrlib.symbol_versioning import (deprecated_method,
92
 
        deprecated_function,
93
 
        zero_eight,
94
 
        )
95
 
from bzrlib.tsort import topo_sort
96
 
from bzrlib.versionedfile import VersionedFile, InterVersionedFile
97
 
from bzrlib.weavefile import _read_weave_v5, write_weave_v5
98
 
 
99
 
 
100
 
class Weave(VersionedFile):
 
99
 
 
100
 
 
101
class WeaveError(Exception):
 
102
    """Exception in processing weave"""
 
103
 
 
104
 
 
105
class WeaveFormatError(WeaveError):
 
106
    """Weave invariant violated"""
 
107
    
 
108
 
 
109
class Weave(object):
101
110
    """weave - versioned text file storage.
102
111
    
103
112
    A Weave manages versions of line-based text files, keeping track
187
196
    """
188
197
 
189
198
    __slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
190
 
                 '_weave_name', '_matcher']
 
199
                 '_weave_name']
191
200
    
192
 
    def __init__(self, weave_name=None, access_mode='w', matcher=None):
193
 
        super(Weave, self).__init__(access_mode)
 
201
    def __init__(self, weave_name=None):
194
202
        self._weave = []
195
203
        self._parents = []
196
204
        self._sha1s = []
197
205
        self._names = []
198
206
        self._name_map = {}
199
207
        self._weave_name = weave_name
200
 
        if matcher is None:
201
 
            self._matcher = bzrlib.patiencediff.PatienceSequenceMatcher
202
 
        else:
203
 
            self._matcher = matcher
204
 
 
205
 
    def __repr__(self):
206
 
        return "Weave(%r)" % self._weave_name
207
 
 
208
 
    def copy(self):
209
 
        """Return a deep copy of self.
210
 
        
211
 
        The copy can be modified without affecting the original weave."""
212
 
        other = Weave()
213
 
        other._weave = self._weave[:]
214
 
        other._parents = self._parents[:]
215
 
        other._sha1s = self._sha1s[:]
216
 
        other._names = self._names[:]
217
 
        other._name_map = self._name_map.copy()
218
 
        other._weave_name = self._weave_name
219
 
        return other
 
208
 
220
209
 
221
210
    def __eq__(self, other):
222
211
        if not isinstance(other, Weave):
224
213
        return self._parents == other._parents \
225
214
               and self._weave == other._weave \
226
215
               and self._sha1s == other._sha1s 
 
216
 
227
217
    
228
218
    def __ne__(self, other):
229
219
        return not self.__eq__(other)
230
220
 
231
 
    @deprecated_method(zero_eight)
232
 
    def idx_to_name(self, index):
233
 
        """Old public interface, the public interface is all names now."""
234
 
        return index
235
 
 
236
 
    def _idx_to_name(self, version):
237
 
        return self._names[version]
238
 
 
239
 
    @deprecated_method(zero_eight)
 
221
 
 
222
    def maybe_lookup(self, name_or_index):
 
223
        """Convert possible symbolic name to index, or pass through indexes."""
 
224
        if isinstance(name_or_index, (int, long)):
 
225
            return name_or_index
 
226
        else:
 
227
            return self.lookup(name_or_index)
 
228
 
 
229
        
240
230
    def lookup(self, name):
241
 
        """Backwards compatibility thunk:
242
 
 
243
 
        Return name, as name is valid in the api now, and spew deprecation
244
 
        warnings everywhere.
245
 
        """
246
 
        return name
247
 
 
248
 
    def _lookup(self, name):
249
231
        """Convert symbolic version name to index."""
250
 
        self.check_not_reserved_id(name)
251
232
        try:
252
233
            return self._name_map[name]
253
234
        except KeyError:
254
 
            raise RevisionNotPresent(name, self._weave_name)
255
 
 
256
 
    @deprecated_method(zero_eight)
257
 
    def iter_names(self):
258
 
        """Deprecated convenience function, please see VersionedFile.names()."""
259
 
        return iter(self.names())
260
 
 
261
 
    @deprecated_method(zero_eight)
262
 
    def names(self):
263
 
        """See Weave.versions for the current api."""
264
 
        return self.versions()
265
 
 
266
 
    def versions(self):
267
 
        """See VersionedFile.versions."""
268
 
        return self._names[:]
269
 
 
270
 
    def has_version(self, version_id):
271
 
        """See VersionedFile.has_version."""
272
 
        return (version_id in self._name_map)
273
 
 
274
 
    __contains__ = has_version
275
 
 
276
 
    def get_delta(self, version_id):
277
 
        """See VersionedFile.get_delta."""
278
 
        return self.get_deltas([version_id])[version_id]
279
 
 
280
 
    def get_deltas(self, version_ids):
281
 
        """See VersionedFile.get_deltas."""
282
 
        version_ids = self.get_ancestry(version_ids)
283
 
        for version_id in version_ids:
284
 
            if not self.has_version(version_id):
285
 
                raise RevisionNotPresent(version_id, self)
286
 
        # try extracting all versions; parallel extraction is used
287
 
        nv = self.num_versions()
288
 
        sha1s = {}
289
 
        deltas = {}
290
 
        texts = {}
291
 
        inclusions = {}
292
 
        noeols = {}
293
 
        last_parent_lines = {}
294
 
        parents = {}
295
 
        parent_inclusions = {}
296
 
        parent_linenums = {}
297
 
        parent_noeols = {}
298
 
        current_hunks = {}
299
 
        diff_hunks = {}
300
 
        # its simplest to generate a full set of prepared variables.
301
 
        for i in range(nv):
302
 
            name = self._names[i]
303
 
            sha1s[name] = self.get_sha1(name)
304
 
            parents_list = self.get_parents(name)
305
 
            try:
306
 
                parent = parents_list[0]
307
 
                parents[name] = parent
308
 
                parent_inclusions[name] = inclusions[parent]
309
 
            except IndexError:
310
 
                parents[name] = None
311
 
                parent_inclusions[name] = set()
312
 
            # we want to emit start, finish, replacement_length, replacement_lines tuples.
313
 
            diff_hunks[name] = []
314
 
            current_hunks[name] = [0, 0, 0, []] # #start, finish, repl_length, repl_tuples
315
 
            parent_linenums[name] = 0
316
 
            noeols[name] = False
317
 
            parent_noeols[name] = False
318
 
            last_parent_lines[name] = None
319
 
            new_inc = set([name])
320
 
            for p in self._parents[i]:
321
 
                new_inc.update(inclusions[self._idx_to_name(p)])
322
 
            # debug only, known good so far.
323
 
            #assert set(new_inc) == set(self.get_ancestry(name)), \
324
 
            #    'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
325
 
            inclusions[name] = new_inc
326
 
 
327
 
        nlines = len(self._weave)
328
 
 
329
 
        for lineno, inserted, deletes, line in self._walk_internal():
330
 
            # a line is active in a version if:
331
 
            # insert is in the versions inclusions
332
 
            # and
333
 
            # deleteset & the versions inclusions is an empty set.
334
 
            # so - if we have a included by mapping - version is included by
335
 
            # children, we get a list of children to examine for deletes affect
336
 
            # ing them, which is less than the entire set of children.
337
 
            for version_id in version_ids:  
338
 
                # The active inclusion must be an ancestor,
339
 
                # and no ancestors must have deleted this line,
340
 
                # because we don't support resurrection.
341
 
                parent_inclusion = parent_inclusions[version_id]
342
 
                inclusion = inclusions[version_id]
343
 
                parent_active = inserted in parent_inclusion and not (deletes & parent_inclusion)
344
 
                version_active = inserted in inclusion and not (deletes & inclusion)
345
 
                if not parent_active and not version_active:
346
 
                    # unrelated line of ancestry
347
 
                    continue
348
 
                elif parent_active and version_active:
349
 
                    # shared line
350
 
                    parent_linenum = parent_linenums[version_id]
351
 
                    if current_hunks[version_id] != [parent_linenum, parent_linenum, 0, []]:
352
 
                        diff_hunks[version_id].append(tuple(current_hunks[version_id]))
353
 
                    parent_linenum += 1
354
 
                    current_hunks[version_id] = [parent_linenum, parent_linenum, 0, []]
355
 
                    parent_linenums[version_id] = parent_linenum
356
 
                    try:
357
 
                        if line[-1] != '\n':
358
 
                            noeols[version_id] = True
359
 
                    except IndexError:
360
 
                        pass
361
 
                elif parent_active and not version_active:
362
 
                    # deleted line
363
 
                    current_hunks[version_id][1] += 1
364
 
                    parent_linenums[version_id] += 1
365
 
                    last_parent_lines[version_id] = line
366
 
                elif not parent_active and version_active:
367
 
                    # replacement line
368
 
                    # noeol only occurs at the end of a file because we 
369
 
                    # diff linewise. We want to show noeol changes as a
370
 
                    # empty diff unless the actual eol-less content changed.
371
 
                    theline = line
372
 
                    try:
373
 
                        if last_parent_lines[version_id][-1] != '\n':
374
 
                            parent_noeols[version_id] = True
375
 
                    except (TypeError, IndexError):
376
 
                        pass
377
 
                    try:
378
 
                        if theline[-1] != '\n':
379
 
                            noeols[version_id] = True
380
 
                    except IndexError:
381
 
                        pass
382
 
                    new_line = False
383
 
                    parent_should_go = False
384
 
 
385
 
                    if parent_noeols[version_id] == noeols[version_id]:
386
 
                        # no noeol toggle, so trust the weaves statement
387
 
                        # that this line is changed.
388
 
                        new_line = True
389
 
                        if parent_noeols[version_id]:
390
 
                            theline = theline + '\n'
391
 
                    elif parent_noeols[version_id]:
392
 
                        # parent has no eol, we do:
393
 
                        # our line is new, report as such..
394
 
                        new_line = True
395
 
                    elif noeols[version_id]:
396
 
                        # append a eol so that it looks like
397
 
                        # a normalised delta
398
 
                        theline = theline + '\n'
399
 
                        if parents[version_id] is not None:
400
 
                        #if last_parent_lines[version_id] is not None:
401
 
                            parent_should_go = True
402
 
                        if last_parent_lines[version_id] != theline:
403
 
                            # but changed anyway
404
 
                            new_line = True
405
 
                            #parent_should_go = False
406
 
                    if new_line:
407
 
                        current_hunks[version_id][2] += 1
408
 
                        current_hunks[version_id][3].append((inserted, theline))
409
 
                    if parent_should_go:
410
 
                        # last hunk last parent line is not eaten
411
 
                        current_hunks[version_id][1] -= 1
412
 
                    if current_hunks[version_id][1] < 0:
413
 
                        current_hunks[version_id][1] = 0
414
 
                        # import pdb;pdb.set_trace()
415
 
                    # assert current_hunks[version_id][1] >= 0
416
 
 
417
 
        # flush last hunk
418
 
        for i in range(nv):
419
 
            version = self._idx_to_name(i)
420
 
            if current_hunks[version] != [0, 0, 0, []]:
421
 
                diff_hunks[version].append(tuple(current_hunks[version]))
422
 
        result = {}
423
 
        for version_id in version_ids:
424
 
            result[version_id] = (
425
 
                                  parents[version_id],
426
 
                                  sha1s[version_id],
427
 
                                  noeols[version_id],
428
 
                                  diff_hunks[version_id],
429
 
                                  )
430
 
        return result
431
 
 
432
 
    def get_parents(self, version_id):
433
 
        """See VersionedFile.get_parent."""
434
 
        return map(self._idx_to_name, self._parents[self._lookup(version_id)])
 
235
            raise WeaveError("name %r not present in weave %r" %
 
236
                             (name, self._weave_name))
 
237
 
 
238
 
 
239
    def idx_to_name(self, version):
 
240
        return self._names[version]
 
241
 
435
242
 
436
243
    def _check_repeated_add(self, name, parents, text, sha1):
437
244
        """Check that a duplicated add is OK.
438
245
 
439
246
        If it is, return the (old) index; otherwise raise an exception.
440
247
        """
441
 
        idx = self._lookup(name)
442
 
        if sorted(self._parents[idx]) != sorted(parents) \
443
 
            or sha1 != self._sha1s[idx]:
444
 
            raise RevisionAlreadyPresent(name, self._weave_name)
 
248
        idx = self.lookup(name)
 
249
        if sorted(self._parents[idx]) != sorted(parents):
 
250
            raise WeaveError("name \"%s\" already present in weave "
 
251
                             "with different parents" % name)
 
252
        if sha1 != self._sha1s[idx]:
 
253
            raise WeaveError("name \"%s\" already present in weave "
 
254
                             "with different text" % name)            
445
255
        return idx
446
 
 
447
 
    @deprecated_method(zero_eight)
448
 
    def add_identical(self, old_rev_id, new_rev_id, parents):
449
 
        """Please use Weave.clone_text now."""
450
 
        return self.clone_text(new_rev_id, old_rev_id, parents)
451
 
 
452
 
    def _add_lines(self, version_id, parents, lines, parent_texts):
453
 
        """See VersionedFile.add_lines."""
454
 
        return self._add(version_id, lines, map(self._lookup, parents))
455
 
 
456
 
    @deprecated_method(zero_eight)
 
256
        
 
257
 
 
258
        
457
259
    def add(self, name, parents, text, sha1=None):
458
 
        """See VersionedFile.add_lines for the non deprecated api."""
459
 
        return self._add(name, text, map(self._maybe_lookup, parents), sha1)
460
 
 
461
 
    def _add(self, version_id, lines, parents, sha1=None):
462
260
        """Add a single text on top of the weave.
463
261
  
464
262
        Returns the index number of the newly added version.
465
263
 
466
 
        version_id
 
264
        name
467
265
            Symbolic name for this version.
468
266
            (Typically the revision-id of the revision that added it.)
469
267
 
470
268
        parents
471
269
            List or set of direct parent version numbers.
472
270
            
473
 
        lines
 
271
        text
474
272
            Sequence of lines to be added in the new version.
 
273
 
 
274
        sha -- SHA-1 of the file, if known.  This is trusted to be
 
275
            correct if supplied.
475
276
        """
476
277
 
477
 
        assert isinstance(version_id, basestring)
478
 
        self._check_lines_not_unicode(lines)
479
 
        self._check_lines_are_lines(lines)
480
 
        if not sha1:
481
 
            sha1 = sha_strings(lines)
482
 
        if version_id in self._name_map:
483
 
            return self._check_repeated_add(version_id, parents, lines, sha1)
 
278
        assert isinstance(name, basestring)
 
279
        if sha1 is None:
 
280
            sha1 = sha_strings(text)
 
281
        if name in self._name_map:
 
282
            return self._check_repeated_add(name, parents, text, sha1)
484
283
 
 
284
        parents = map(self.maybe_lookup, parents)
485
285
        self._check_versions(parents)
486
 
        ## self._check_lines(lines)
 
286
        ## self._check_lines(text)
487
287
        new_version = len(self._parents)
488
288
 
 
289
 
489
290
        # if we abort after here the (in-memory) weave will be corrupt because only
490
291
        # some fields are updated
491
 
        # XXX: FIXME implement a succeed-or-fail of the rest of this routine.
492
 
        #      - Robert Collins 20060226
493
292
        self._parents.append(parents[:])
494
293
        self._sha1s.append(sha1)
495
 
        self._names.append(version_id)
496
 
        self._name_map[version_id] = new_version
 
294
        self._names.append(name)
 
295
        self._name_map[name] = new_version
497
296
 
498
297
            
499
298
        if not parents:
501
300
            # this more quickly by just appending unconditionally.
502
301
            # even more specially, if we're adding an empty text we
503
302
            # need do nothing at all.
504
 
            if lines:
 
303
            if text:
505
304
                self._weave.append(('{', new_version))
506
 
                self._weave.extend(lines)
 
305
                self._weave.extend(text)
507
306
                self._weave.append(('}', None))
 
307
        
508
308
            return new_version
509
309
 
510
310
        if len(parents) == 1:
514
314
                return new_version
515
315
            
516
316
 
517
 
        ancestors = self._inclusions(parents)
 
317
        ancestors = self.inclusions(parents)
518
318
 
519
319
        l = self._weave
520
320
 
527
327
 
528
328
        # another small special case: a merge, producing the same text
529
329
        # as auto-merge
530
 
        if lines == basis_lines:
 
330
        if text == basis_lines:
531
331
            return new_version            
532
332
 
533
 
        # add a sentinel, because we can also match against the final line
 
333
        # add a sentinal, because we can also match against the final line
534
334
        basis_lineno.append(len(self._weave))
535
335
 
536
336
        # XXX: which line of the weave should we really consider
540
340
        #print 'basis_lines:', basis_lines
541
341
        #print 'new_lines:  ', lines
542
342
 
543
 
        s = self._matcher(None, basis_lines, lines)
 
343
        s = SequenceMatcher(None, basis_lines, text)
544
344
 
545
345
        # offset gives the number of lines that have been inserted
546
346
        # into the weave up to the current point; if the original edit instruction
557
357
            i1 = basis_lineno[i1]
558
358
            i2 = basis_lineno[i2]
559
359
 
560
 
            assert 0 <= j1 <= j2 <= len(lines)
 
360
            assert 0 <= j1 <= j2 <= len(text)
561
361
 
562
362
            #print tag, i1, i2, j1, j2
563
363
 
574
374
                # we don't destroy ourselves
575
375
                i = i2 + offset
576
376
                self._weave[i:i] = ([('{', new_version)] 
577
 
                                    + lines[j1:j2] 
 
377
                                    + text[j1:j2] 
578
378
                                    + [('}', None)])
579
379
                offset += 2 + (j2 - j1)
 
380
 
580
381
        return new_version
581
382
 
582
 
    def _clone_text(self, new_version_id, old_version_id, parents):
583
 
        """See VersionedFile.clone_text."""
584
 
        old_lines = self.get_text(old_version_id)
585
 
        self.add_lines(new_version_id, parents, old_lines)
586
383
 
587
 
    def _inclusions(self, versions):
 
384
    def inclusions(self, versions):
588
385
        """Return set of all ancestors of given version(s)."""
589
 
        if not len(versions):
590
 
            return []
591
386
        i = set(versions)
592
387
        for v in xrange(max(versions), 0, -1):
593
388
            if v in i:
597
392
        ## except IndexError:
598
393
        ##     raise ValueError("version %d not present in weave" % v)
599
394
 
600
 
    @deprecated_method(zero_eight)
601
 
    def inclusions(self, version_ids):
602
 
        """Deprecated - see VersionedFile.get_ancestry for the replacement."""
603
 
        if not version_ids:
 
395
 
 
396
    def parents(self, version):
 
397
        return self._parents[version]
 
398
 
 
399
 
 
400
    def minimal_parents(self, version):
 
401
        """Find the minimal set of parents for the version."""
 
402
        included = self._parents[version]
 
403
        if not included:
604
404
            return []
605
 
        if isinstance(version_ids[0], int):
606
 
            return [self._idx_to_name(v) for v in self._inclusions(version_ids)]
607
 
        else:
608
 
            return self.get_ancestry(version_ids)
609
 
 
610
 
    def get_ancestry(self, version_ids, topo_sorted=True):
611
 
        """See VersionedFile.get_ancestry."""
612
 
        if isinstance(version_ids, basestring):
613
 
            version_ids = [version_ids]
614
 
        i = self._inclusions([self._lookup(v) for v in version_ids])
615
 
        return [self._idx_to_name(v) for v in i]
 
405
        
 
406
        li = list(included)
 
407
        li.sort(reverse=True)
 
408
 
 
409
        mininc = []
 
410
        gotit = set()
 
411
 
 
412
        for pv in li:
 
413
            if pv not in gotit:
 
414
                mininc.append(pv)
 
415
                gotit.update(self.inclusions(pv))
 
416
 
 
417
        assert mininc[0] >= 0
 
418
        assert mininc[-1] < version
 
419
        return mininc
 
420
 
 
421
 
616
422
 
617
423
    def _check_lines(self, text):
618
424
        if not isinstance(text, list):
633
439
            except IndexError:
634
440
                raise IndexError("invalid version number %r" % i)
635
441
 
636
 
    def _compatible_parents(self, my_parents, other_parents):
637
 
        """During join check that other_parents are joinable with my_parents.
638
 
 
639
 
        Joinable is defined as 'is a subset of' - supersets may require 
640
 
        regeneration of diffs, but subsets do not.
641
 
        """
642
 
        return len(other_parents.difference(my_parents)) == 0
643
 
 
644
 
    def annotate_iter(self, version_id):
645
 
        """Yield list of (version-id, line) pairs for the specified version.
 
442
    
 
443
    def annotate(self, name_or_index):
 
444
        return list(self.annotate_iter(name_or_index))
 
445
 
 
446
 
 
447
    def annotate_iter(self, name_or_index):
 
448
        """Yield list of (index-id, line) pairs for the specified version.
646
449
 
647
450
        The index indicates when the line originated in the weave."""
648
 
        incls = [self._lookup(version_id)]
 
451
        incls = [self.maybe_lookup(name_or_index)]
649
452
        for origin, lineno, text in self._extract(incls):
650
 
            yield self._idx_to_name(origin), text
651
 
 
652
 
    @deprecated_method(zero_eight)
 
453
            yield origin, text
 
454
 
 
455
 
653
456
    def _walk(self):
654
 
        """_walk has become visit, a supported api."""
655
 
        return self._walk_internal()
656
 
 
657
 
    def iter_lines_added_or_present_in_versions(self, version_ids=None,
658
 
                                                pb=None):
659
 
        """See VersionedFile.iter_lines_added_or_present_in_versions()."""
660
 
        if version_ids is None:
661
 
            version_ids = self.versions()
662
 
        version_ids = set(version_ids)
663
 
        for lineno, inserted, deletes, line in self._walk_internal(version_ids):
664
 
            # if inserted not in version_ids then it was inserted before the
665
 
            # versions we care about, but because weaves cannot represent ghosts
666
 
            # properly, we do not filter down to that
667
 
            # if inserted not in version_ids: continue
668
 
            if line[-1] != '\n':
669
 
                yield line + '\n'
670
 
            else:
671
 
                yield line
672
 
 
673
 
    #@deprecated_method(zero_eight)
674
 
    def walk(self, version_ids=None):
675
 
        """See VersionedFile.walk."""
676
 
        return self._walk_internal(version_ids)
677
 
 
678
 
    def _walk_internal(self, version_ids=None):
679
 
        """Helper method for weave actions."""
 
457
        """Walk the weave.
 
458
 
 
459
        Yields sequence of
 
460
        (lineno, insert, deletes, text)
 
461
        for each literal line.
 
462
        """
680
463
        
681
464
        istack = []
682
465
        dset = set()
684
467
        lineno = 0         # line of weave, 0-based
685
468
 
686
469
        for l in self._weave:
687
 
            if l.__class__ == tuple:
 
470
            if isinstance(l, tuple):
688
471
                c, v = l
689
472
                isactive = None
690
473
                if c == '{':
691
 
                    istack.append(self._names[v])
 
474
                    istack.append(v)
692
475
                elif c == '}':
693
476
                    istack.pop()
694
477
                elif c == '[':
695
 
                    assert self._names[v] not in dset
696
 
                    dset.add(self._names[v])
 
478
                    assert v not in dset
 
479
                    dset.add(v)
697
480
                elif c == ']':
698
 
                    dset.remove(self._names[v])
 
481
                    dset.remove(v)
699
482
                else:
700
 
                    raise WeaveFormatError('unexpected instruction %r' % v)
 
483
                    raise WeaveFormatError('unexpected instruction %r'
 
484
                                           % v)
701
485
            else:
702
 
                assert l.__class__ in (str, unicode)
 
486
                assert isinstance(l, basestring)
703
487
                assert istack
704
 
                yield lineno, istack[-1], frozenset(dset), l
 
488
                yield lineno, istack[-1], dset, l
705
489
            lineno += 1
706
490
 
707
 
        if istack:
708
 
            raise WeaveFormatError("unclosed insertion blocks "
709
 
                    "at end of weave: %s" % istack)
710
 
        if dset:
711
 
            raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
712
 
                                   % dset)
713
 
 
714
 
    def plan_merge(self, ver_a, ver_b):
715
 
        """Return pseudo-annotation indicating how the two versions merge.
716
 
 
717
 
        This is computed between versions a and b and their common
718
 
        base.
719
 
 
720
 
        Weave lines present in none of them are skipped entirely.
721
 
        """
722
 
        inc_a = set(self.get_ancestry([ver_a]))
723
 
        inc_b = set(self.get_ancestry([ver_b]))
724
 
        inc_c = inc_a & inc_b
725
 
 
726
 
        for lineno, insert, deleteset, line in\
727
 
            self.walk([ver_a, ver_b]):
728
 
            if deleteset & inc_c:
729
 
                # killed in parent; can't be in either a or b
730
 
                # not relevant to our work
731
 
                yield 'killed-base', line
732
 
            elif insert in inc_c:
733
 
                # was inserted in base
734
 
                killed_a = bool(deleteset & inc_a)
735
 
                killed_b = bool(deleteset & inc_b)
736
 
                if killed_a and killed_b:
737
 
                    yield 'killed-both', line
738
 
                elif killed_a:
739
 
                    yield 'killed-a', line
740
 
                elif killed_b:
741
 
                    yield 'killed-b', line
742
 
                else:
743
 
                    yield 'unchanged', line
744
 
            elif insert in inc_a:
745
 
                if deleteset & inc_a:
746
 
                    yield 'ghost-a', line
747
 
                else:
748
 
                    # new in A; not in B
749
 
                    yield 'new-a', line
750
 
            elif insert in inc_b:
751
 
                if deleteset & inc_b:
752
 
                    yield 'ghost-b', line
753
 
                else:
754
 
                    yield 'new-b', line
755
 
            else:
756
 
                # not in either revision
757
 
                yield 'irrelevant', line
758
 
 
759
 
        yield 'unchanged', ''           # terminator
 
491
 
760
492
 
761
493
    def _extract(self, versions):
762
494
        """Yield annotation of lines in included set.
771
503
            if not isinstance(i, int):
772
504
                raise ValueError(i)
773
505
            
774
 
        included = self._inclusions(versions)
 
506
        included = self.inclusions(versions)
775
507
 
776
508
        istack = []
777
 
        iset = set()
778
509
        dset = set()
779
510
 
780
511
        lineno = 0         # line of weave, 0-based
785
516
 
786
517
        WFE = WeaveFormatError
787
518
 
788
 
        # wow. 
789
 
        #  449       0   4474.6820   2356.5590   bzrlib.weave:556(_extract)
790
 
        #  +285282   0   1676.8040   1676.8040   +<isinstance>
791
 
        # 1.6 seconds in 'isinstance'.
792
 
        # changing the first isinstance:
793
 
        #  449       0   2814.2660   1577.1760   bzrlib.weave:556(_extract)
794
 
        #  +140414   0    762.8050    762.8050   +<isinstance>
795
 
        # note that the inline time actually dropped (less function calls)
796
 
        # and total processing time was halved.
797
 
        # we're still spending ~1/4 of the method in isinstance though.
798
 
        # so lets hard code the acceptable string classes we expect:
799
 
        #  449       0   1202.9420    786.2930   bzrlib.weave:556(_extract)
800
 
        # +71352     0    377.5560    377.5560   +<method 'append' of 'list' 
801
 
        #                                          objects>
802
 
        # yay, down to ~1/4 the initial extract time, and our inline time
803
 
        # has shrunk again, with isinstance no longer dominating.
804
 
        # tweaking the stack inclusion test to use a set gives:
805
 
        #  449       0   1122.8030    713.0080   bzrlib.weave:556(_extract)
806
 
        # +71352     0    354.9980    354.9980   +<method 'append' of 'list' 
807
 
        #                                          objects>
808
 
        # - a 5% win, or possibly just noise. However with large istacks that
809
 
        # 'in' test could dominate, so I'm leaving this change in place -
810
 
        # when its fast enough to consider profiling big datasets we can review.
811
 
 
812
 
              
813
 
             
814
 
 
815
519
        for l in self._weave:
816
 
            if l.__class__ == tuple:
 
520
            if isinstance(l, tuple):
817
521
                c, v = l
818
522
                isactive = None
819
523
                if c == '{':
820
 
                    assert v not in iset
 
524
                    assert v not in istack
821
525
                    istack.append(v)
822
 
                    iset.add(v)
823
526
                elif c == '}':
824
 
                    iset.remove(istack.pop())
 
527
                    istack.pop()
825
528
                elif c == '[':
826
529
                    if v in included:
827
530
                        assert v not in dset
832
535
                        assert v in dset
833
536
                        dset.remove(v)
834
537
            else:
835
 
                assert l.__class__ in (str, unicode)
 
538
                assert isinstance(l, basestring)
836
539
                if isactive is None:
837
540
                    isactive = (not dset) and istack and (istack[-1] in included)
838
541
                if isactive:
839
542
                    result.append((istack[-1], lineno, l))
840
543
            lineno += 1
 
544
 
841
545
        if istack:
842
 
            raise WeaveFormatError("unclosed insertion blocks "
843
 
                    "at end of weave: %s" % istack)
 
546
            raise WFE("unclosed insertion blocks at end of weave",
 
547
                                   istack)
844
548
        if dset:
845
 
            raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
846
 
                                   % dset)
 
549
            raise WFE("unclosed deletion blocks at end of weave",
 
550
                                   dset)
 
551
 
847
552
        return result
848
 
 
849
 
    @deprecated_method(zero_eight)
 
553
    
 
554
 
 
555
 
850
556
    def get_iter(self, name_or_index):
851
 
        """Deprecated, please do not use. Lookups are not not needed.
852
 
        
853
 
        Please use get_lines now.
854
 
        """
855
 
        return iter(self.get_lines(self._maybe_lookup(name_or_index)))
856
 
 
857
 
    @deprecated_method(zero_eight)
858
 
    def maybe_lookup(self, name_or_index):
859
 
        """Deprecated, please do not use. Lookups are not not needed."""
860
 
        return self._maybe_lookup(name_or_index)
861
 
 
862
 
    def _maybe_lookup(self, name_or_index):
863
 
        """Convert possible symbolic name to index, or pass through indexes.
864
 
        
865
 
        NOT FOR PUBLIC USE.
866
 
        """
867
 
        if isinstance(name_or_index, (int, long)):
868
 
            return name_or_index
869
 
        else:
870
 
            return self._lookup(name_or_index)
871
 
 
872
 
    @deprecated_method(zero_eight)
873
 
    def get(self, version_id):
874
 
        """Please use either Weave.get_text or Weave.get_lines as desired."""
875
 
        return self.get_lines(version_id)
876
 
 
877
 
    def get_lines(self, version_id):
878
 
        """See VersionedFile.get_lines()."""
879
 
        int_index = self._maybe_lookup(version_id)
880
 
        result = [line for (origin, lineno, line) in self._extract([int_index])]
881
 
        expected_sha1 = self._sha1s[int_index]
882
 
        measured_sha1 = sha_strings(result)
883
 
        if measured_sha1 != expected_sha1:
884
 
            raise errors.WeaveInvalidChecksum(
885
 
                    'file %s, revision %s, expected: %s, measured %s' 
886
 
                    % (self._weave_name, version_id,
887
 
                       expected_sha1, measured_sha1))
888
 
        return result
889
 
 
890
 
    def get_sha1(self, version_id):
891
 
        """See VersionedFile.get_sha1()."""
892
 
        return self._sha1s[self._lookup(version_id)]
893
 
 
894
 
    @deprecated_method(zero_eight)
 
557
        """Yield lines for the specified version."""
 
558
        incls = [self.maybe_lookup(name_or_index)]
 
559
        for origin, lineno, line in self._extract(incls):
 
560
            yield line
 
561
 
 
562
 
 
563
    def get_text(self, version):
 
564
        assert isinstance(version, int)
 
565
        s = StringIO()
 
566
        s.writelines(self.get_iter(version))
 
567
        return s.getvalue()
 
568
 
 
569
 
 
570
    def get(self, name_or_index):
 
571
        return list(self.get_iter(name_or_index))
 
572
 
 
573
 
 
574
    def mash_iter(self, included):
 
575
        """Return composed version of multiple included versions."""
 
576
        included = map(self.maybe_lookup, included)
 
577
        for origin, lineno, text in self._extract(included):
 
578
            yield text
 
579
 
 
580
 
 
581
    def dump(self, to_file):
 
582
        from pprint import pprint
 
583
        print >>to_file, "Weave._weave = ",
 
584
        pprint(self._weave, to_file)
 
585
        print >>to_file, "Weave._parents = ",
 
586
        pprint(self._parents, to_file)
 
587
 
 
588
 
 
589
 
895
590
    def numversions(self):
896
 
        """How many versions are in this weave?
897
 
 
898
 
        Deprecated in favour of num_versions.
899
 
        """
900
 
        return self.num_versions()
901
 
 
902
 
    def num_versions(self):
903
 
        """How many versions are in this weave?"""
904
591
        l = len(self._parents)
905
592
        assert l == len(self._sha1s)
906
593
        return l
907
594
 
908
 
    __len__ = num_versions
 
595
 
 
596
    def __len__(self):
 
597
        return self.numversions()
 
598
 
909
599
 
910
600
    def check(self, progress_bar=None):
911
 
        # TODO evaluate performance hit of using string sets in this routine.
912
 
        # TODO: check no circular inclusions
913
 
        # TODO: create a nested progress bar
914
 
        for version in range(self.num_versions()):
 
601
        # check no circular inclusions
 
602
        for version in range(self.numversions()):
915
603
            inclusions = list(self._parents[version])
916
604
            if inclusions:
917
605
                inclusions.sort()
919
607
                    raise WeaveFormatError("invalid included version %d for index %d"
920
608
                                           % (inclusions[-1], version))
921
609
 
922
 
        # try extracting all versions; parallel extraction is used
923
 
        nv = self.num_versions()
924
 
        sha1s = {}
925
 
        texts = {}
926
 
        inclusions = {}
927
 
        for i in range(nv):
928
 
            # For creating the ancestry, IntSet is much faster (3.7s vs 0.17s)
929
 
            # The problem is that set membership is much more expensive
930
 
            name = self._idx_to_name(i)
931
 
            sha1s[name] = sha.new()
932
 
            texts[name] = []
933
 
            new_inc = set([name])
934
 
            for p in self._parents[i]:
935
 
                new_inc.update(inclusions[self._idx_to_name(p)])
936
 
 
937
 
            assert set(new_inc) == set(self.get_ancestry(name)), \
938
 
                'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
939
 
            inclusions[name] = new_inc
940
 
 
941
 
        nlines = len(self._weave)
942
 
 
943
 
        update_text = 'checking weave'
944
 
        if self._weave_name:
945
 
            short_name = os.path.basename(self._weave_name)
946
 
            update_text = 'checking %s' % (short_name,)
947
 
            update_text = update_text[:25]
948
 
 
949
 
        for lineno, insert, deleteset, line in self._walk_internal():
 
610
        # try extracting all versions; this is a bit slow and parallel
 
611
        # extraction could be used
 
612
        nv = self.numversions()
 
613
        for version in range(nv):
950
614
            if progress_bar:
951
 
                progress_bar.update(update_text, lineno, nlines)
952
 
 
953
 
            for name, name_inclusions in inclusions.items():
954
 
                # The active inclusion must be an ancestor,
955
 
                # and no ancestors must have deleted this line,
956
 
                # because we don't support resurrection.
957
 
                if (insert in name_inclusions) and not (deleteset & name_inclusions):
958
 
                    sha1s[name].update(line)
959
 
 
960
 
        for i in range(nv):
961
 
            version = self._idx_to_name(i)
962
 
            hd = sha1s[version].hexdigest()
963
 
            expected = self._sha1s[i]
 
615
                progress_bar.update('checking text', version, nv)
 
616
            s = sha.new()
 
617
            for l in self.get_iter(version):
 
618
                s.update(l)
 
619
            hd = s.hexdigest()
 
620
            expected = self._sha1s[version]
964
621
            if hd != expected:
965
 
                raise errors.WeaveInvalidChecksum(
966
 
                        "mismatched sha1 for version %s: "
967
 
                        "got %s, expected %s"
968
 
                        % (version, hd, expected))
 
622
                raise WeaveError("mismatched sha1 for version %d; "
 
623
                                 "got %s, expected %s"
 
624
                                 % (version, hd, expected))
969
625
 
970
626
        # TODO: check insertions are properly nested, that there are
971
627
        # no lines outside of insertion blocks, that deletions are
972
628
        # properly paired, etc.
973
629
 
974
 
    def _join(self, other, pb, msg, version_ids, ignore_missing):
975
 
        """Worker routine for join()."""
976
 
        if not other.versions():
977
 
            return          # nothing to update, easy
978
 
 
979
 
        if not version_ids:
980
 
            # versions is never none, InterWeave checks this.
981
 
            return 0
982
 
 
983
 
        # two loops so that we do not change ourselves before verifying it
984
 
        # will be ok
985
 
        # work through in index order to make sure we get all dependencies
986
 
        names_to_join = []
987
 
        processed = 0
988
 
        # get the selected versions only that are in other.versions.
989
 
        version_ids = set(other.versions()).intersection(set(version_ids))
990
 
        # pull in the referenced graph.
991
 
        version_ids = other.get_ancestry(version_ids)
992
 
        pending_graph = [(version, other.get_parents(version)) for
993
 
                         version in version_ids]
994
 
        for name in topo_sort(pending_graph):
995
 
            other_idx = other._name_map[name]
996
 
            # returns True if we have it, False if we need it.
997
 
            if not self._check_version_consistent(other, other_idx, name):
998
 
                names_to_join.append((other_idx, name))
999
 
            processed += 1
1000
 
 
1001
 
 
1002
 
        if pb and not msg:
1003
 
            msg = 'weave join'
1004
 
 
1005
 
        merged = 0
1006
 
        time0 = time.time()
1007
 
        for other_idx, name in names_to_join:
1008
 
            # TODO: If all the parents of the other version are already
1009
 
            # present then we can avoid some work by just taking the delta
1010
 
            # and adjusting the offsets.
1011
 
            new_parents = self._imported_parents(other, other_idx)
1012
 
            sha1 = other._sha1s[other_idx]
1013
 
 
1014
 
            merged += 1
1015
 
 
1016
 
            if pb:
1017
 
                pb.update(msg, merged, len(names_to_join))
1018
 
           
1019
 
            lines = other.get_lines(other_idx)
1020
 
            self._add(name, lines, new_parents, sha1)
1021
 
 
1022
 
        mutter("merged = %d, processed = %d, file_id=%s; deltat=%d"%(
1023
 
                merged, processed, self._weave_name, time.time()-time0))
1024
 
 
1025
 
    def _imported_parents(self, other, other_idx):
1026
 
        """Return list of parents in self corresponding to indexes in other."""
1027
 
        new_parents = []
1028
 
        for parent_idx in other._parents[other_idx]:
1029
 
            parent_name = other._names[parent_idx]
1030
 
            if parent_name not in self._name_map:
1031
 
                # should not be possible
1032
 
                raise WeaveError("missing parent {%s} of {%s} in %r" 
1033
 
                                 % (parent_name, other._name_map[other_idx], self))
1034
 
            new_parents.append(self._name_map[parent_name])
1035
 
        return new_parents
1036
 
 
1037
 
    def _check_version_consistent(self, other, other_idx, name):
1038
 
        """Check if a version in consistent in this and other.
1039
 
 
1040
 
        To be consistent it must have:
1041
 
 
1042
 
         * the same text
1043
 
         * the same direct parents (by name, not index, and disregarding
1044
 
           order)
1045
 
        
1046
 
        If present & correct return True;
1047
 
        if not present in self return False; 
1048
 
        if inconsistent raise error."""
1049
 
        this_idx = self._name_map.get(name, -1)
1050
 
        if this_idx != -1:
1051
 
            if self._sha1s[this_idx] != other._sha1s[other_idx]:
1052
 
                raise errors.WeaveTextDiffers(name, self, other)
1053
 
            self_parents = self._parents[this_idx]
1054
 
            other_parents = other._parents[other_idx]
1055
 
            n1 = set([self._names[i] for i in self_parents])
1056
 
            n2 = set([other._names[i] for i in other_parents])
1057
 
            if not self._compatible_parents(n1, n2):
1058
 
                raise WeaveParentMismatch("inconsistent parents "
1059
 
                    "for version {%s}: %s vs %s" % (name, n1, n2))
1060
 
            else:
1061
 
                return True         # ok!
1062
 
        else:
1063
 
            return False
1064
 
 
1065
 
    @deprecated_method(zero_eight)
1066
 
    def reweave(self, other, pb=None, msg=None):
1067
 
        """reweave has been superseded by plain use of join."""
1068
 
        return self.join(other, pb, msg)
1069
 
 
1070
 
    def _reweave(self, other, pb, msg):
1071
 
        """Reweave self with other - internal helper for join().
1072
 
 
1073
 
        :param other: The other weave to merge
1074
 
        :param pb: An optional progress bar, indicating how far done we are
1075
 
        :param msg: An optional message for the progress
1076
 
        """
1077
 
        new_weave = _reweave(self, other, pb=pb, msg=msg)
1078
 
        self._copy_weave_content(new_weave)
1079
 
 
1080
 
    def _copy_weave_content(self, otherweave):
1081
 
        """adsorb the content from otherweave."""
1082
 
        for attr in self.__slots__:
1083
 
            if attr != '_weave_name':
1084
 
                setattr(self, attr, copy(getattr(otherweave, attr)))
1085
 
 
1086
 
 
1087
 
class WeaveFile(Weave):
1088
 
    """A WeaveFile represents a Weave on disk and writes on change."""
1089
 
 
1090
 
    WEAVE_SUFFIX = '.weave'
1091
 
    
1092
 
    def __init__(self, name, transport, filemode=None, create=False, access_mode='w'):
1093
 
        """Create a WeaveFile.
1094
 
        
1095
 
        :param create: If not True, only open an existing knit.
1096
 
        """
1097
 
        super(WeaveFile, self).__init__(name, access_mode)
1098
 
        self._transport = transport
1099
 
        self._filemode = filemode
1100
 
        try:
1101
 
            _read_weave_v5(self._transport.get(name + WeaveFile.WEAVE_SUFFIX), self)
1102
 
        except errors.NoSuchFile:
1103
 
            if not create:
1104
 
                raise
1105
 
            # new file, save it
1106
 
            self._save()
1107
 
 
1108
 
    def _add_lines(self, version_id, parents, lines, parent_texts):
1109
 
        """Add a version and save the weave."""
1110
 
        self.check_not_reserved_id(version_id)
1111
 
        result = super(WeaveFile, self)._add_lines(version_id, parents, lines,
1112
 
                                                   parent_texts)
1113
 
        self._save()
1114
 
        return result
1115
 
 
1116
 
    def _clone_text(self, new_version_id, old_version_id, parents):
1117
 
        """See VersionedFile.clone_text."""
1118
 
        super(WeaveFile, self)._clone_text(new_version_id, old_version_id, parents)
1119
 
        self._save
1120
 
 
1121
 
    def copy_to(self, name, transport):
1122
 
        """See VersionedFile.copy_to()."""
1123
 
        # as we are all in memory always, just serialise to the new place.
1124
 
        sio = StringIO()
1125
 
        write_weave_v5(self, sio)
1126
 
        sio.seek(0)
1127
 
        transport.put_file(name + WeaveFile.WEAVE_SUFFIX, sio, self._filemode)
1128
 
 
1129
 
    def create_empty(self, name, transport, filemode=None):
1130
 
        return WeaveFile(name, transport, filemode, create=True)
1131
 
 
1132
 
    def _save(self):
1133
 
        """Save the weave."""
1134
 
        self._check_write_ok()
1135
 
        sio = StringIO()
1136
 
        write_weave_v5(self, sio)
1137
 
        sio.seek(0)
1138
 
        self._transport.put_file(self._weave_name + WeaveFile.WEAVE_SUFFIX,
1139
 
                                 sio,
1140
 
                                 self._filemode)
1141
 
 
1142
 
    @staticmethod
1143
 
    def get_suffixes():
1144
 
        """See VersionedFile.get_suffixes()."""
1145
 
        return [WeaveFile.WEAVE_SUFFIX]
1146
 
 
1147
 
    def join(self, other, pb=None, msg=None, version_ids=None,
1148
 
             ignore_missing=False):
1149
 
        """Join other into self and save."""
1150
 
        super(WeaveFile, self).join(other, pb, msg, version_ids, ignore_missing)
1151
 
        self._save()
1152
 
 
1153
 
 
1154
 
@deprecated_function(zero_eight)
1155
 
def reweave(wa, wb, pb=None, msg=None):
1156
 
    """reweaving is deprecation, please just use weave.join()."""
1157
 
    _reweave(wa, wb, pb, msg)
1158
 
 
1159
 
def _reweave(wa, wb, pb=None, msg=None):
1160
 
    """Combine two weaves and return the result.
1161
 
 
1162
 
    This works even if a revision R has different parents in 
1163
 
    wa and wb.  In the resulting weave all the parents are given.
1164
 
 
1165
 
    This is done by just building up a new weave, maintaining ordering 
1166
 
    of the versions in the two inputs.  More efficient approaches
1167
 
    might be possible but it should only be necessary to do 
1168
 
    this operation rarely, when a new previously ghost version is 
1169
 
    inserted.
1170
 
 
1171
 
    :param pb: An optional progress bar, indicating how far done we are
1172
 
    :param msg: An optional message for the progress
1173
 
    """
1174
 
    wr = Weave()
1175
 
    ia = ib = 0
1176
 
    queue_a = range(wa.num_versions())
1177
 
    queue_b = range(wb.num_versions())
1178
 
    # first determine combined parents of all versions
1179
 
    # map from version name -> all parent names
1180
 
    combined_parents = _reweave_parent_graphs(wa, wb)
1181
 
    mutter("combined parents: %r", combined_parents)
1182
 
    order = topo_sort(combined_parents.iteritems())
1183
 
    mutter("order to reweave: %r", order)
1184
 
 
1185
 
    if pb and not msg:
1186
 
        msg = 'reweave'
1187
 
 
1188
 
    for idx, name in enumerate(order):
1189
 
        if pb:
1190
 
            pb.update(msg, idx, len(order))
1191
 
        if name in wa._name_map:
1192
 
            lines = wa.get_lines(name)
1193
 
            if name in wb._name_map:
1194
 
                lines_b = wb.get_lines(name)
1195
 
                if lines != lines_b:
1196
 
                    mutter('Weaves differ on content. rev_id {%s}', name)
1197
 
                    mutter('weaves: %s, %s', wa._weave_name, wb._weave_name)
1198
 
                    import difflib
1199
 
                    lines = list(difflib.unified_diff(lines, lines_b,
1200
 
                            wa._weave_name, wb._weave_name))
1201
 
                    mutter('lines:\n%s', ''.join(lines))
1202
 
                    raise errors.WeaveTextDiffers(name, wa, wb)
1203
 
        else:
1204
 
            lines = wb.get_lines(name)
1205
 
        wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
1206
 
    return wr
1207
 
 
1208
 
def _reweave_parent_graphs(wa, wb):
1209
 
    """Return combined parent ancestry for two weaves.
1210
 
    
1211
 
    Returned as a list of (version_name, set(parent_names))"""
1212
 
    combined = {}
1213
 
    for weave in [wa, wb]:
1214
 
        for idx, name in enumerate(weave._names):
1215
 
            p = combined.setdefault(name, set())
1216
 
            p.update(map(weave._idx_to_name, weave._parents[idx]))
1217
 
    return combined
 
630
 
 
631
 
 
632
    def merge(self, merge_versions):
 
633
        """Automerge and mark conflicts between versions.
 
634
 
 
635
        This returns a sequence, each entry describing alternatives
 
636
        for a chunk of the file.  Each of the alternatives is given as
 
637
        a list of lines.
 
638
 
 
639
        If there is a chunk of the file where there's no diagreement,
 
640
        only one alternative is given.
 
641
        """
 
642
 
 
643
        # approach: find the included versions common to all the
 
644
        # merged versions
 
645
        raise NotImplementedError()
 
646
 
 
647
 
 
648
 
 
649
    def _delta(self, included, lines):
 
650
        """Return changes from basis to new revision.
 
651
 
 
652
        The old text for comparison is the union of included revisions.
 
653
 
 
654
        This is used in inserting a new text.
 
655
 
 
656
        Delta is returned as a sequence of
 
657
        (weave1, weave2, newlines).
 
658
 
 
659
        This indicates that weave1:weave2 of the old weave should be
 
660
        replaced by the sequence of lines in newlines.  Note that
 
661
        these line numbers are positions in the total weave and don't
 
662
        correspond to the lines in any extracted version, or even the
 
663
        extracted union of included versions.
 
664
 
 
665
        If line1=line2, this is a pure insert; if newlines=[] this is a
 
666
        pure delete.  (Similar to difflib.)
 
667
        """
 
668
 
 
669
 
 
670
            
 
671
    def plan_merge(self, ver_a, ver_b):
 
672
        """Return pseudo-annotation indicating how the two versions merge.
 
673
 
 
674
        This is computed between versions a and b and their common
 
675
        base.
 
676
 
 
677
        Weave lines present in none of them are skipped entirely.
 
678
        """
 
679
        inc_a = self.inclusions([ver_a])
 
680
        inc_b = self.inclusions([ver_b])
 
681
        inc_c = inc_a & inc_b
 
682
 
 
683
        for lineno, insert, deleteset, line in self._walk():
 
684
            if deleteset & inc_c:
 
685
                # killed in parent; can't be in either a or b
 
686
                # not relevant to our work
 
687
                yield 'killed-base', line
 
688
            elif insert in inc_c:
 
689
                # was inserted in base
 
690
                killed_a = bool(deleteset & inc_a)
 
691
                killed_b = bool(deleteset & inc_b)
 
692
                if killed_a and killed_b:
 
693
                    yield 'killed-both', line
 
694
                elif killed_a:
 
695
                    yield 'killed-a', line
 
696
                elif killed_b:
 
697
                    yield 'killed-b', line
 
698
                else:
 
699
                    yield 'unchanged', line
 
700
            elif insert in inc_a:
 
701
                if deleteset & inc_a:
 
702
                    yield 'ghost-a', line
 
703
                else:
 
704
                    # new in A; not in B
 
705
                    yield 'new-a', line
 
706
            elif insert in inc_b:
 
707
                if deleteset & inc_b:
 
708
                    yield 'ghost-b', line
 
709
                else:
 
710
                    yield 'new-b', line
 
711
            else:
 
712
                # not in either revision
 
713
                yield 'irrelevant', line
 
714
 
 
715
        yield 'unchanged', ''           # terminator
 
716
 
 
717
 
 
718
 
 
719
    def weave_merge(self, plan):
 
720
        lines_a = []
 
721
        lines_b = []
 
722
        ch_a = ch_b = False
 
723
 
 
724
        for state, line in plan:
 
725
            if state == 'unchanged' or state == 'killed-both':
 
726
                # resync and flush queued conflicts changes if any
 
727
                if not lines_a and not lines_b:
 
728
                    pass
 
729
                elif ch_a and not ch_b:
 
730
                    # one-sided change:                    
 
731
                    for l in lines_a: yield l
 
732
                elif ch_b and not ch_a:
 
733
                    for l in lines_b: yield l
 
734
                elif lines_a == lines_b:
 
735
                    for l in lines_a: yield l
 
736
                else:
 
737
                    yield '<<<<\n'
 
738
                    for l in lines_a: yield l
 
739
                    yield '====\n'
 
740
                    for l in lines_b: yield l
 
741
                    yield '>>>>\n'
 
742
 
 
743
                del lines_a[:]
 
744
                del lines_b[:]
 
745
                ch_a = ch_b = False
 
746
                
 
747
            if state == 'unchanged':
 
748
                if line:
 
749
                    yield line
 
750
            elif state == 'killed-a':
 
751
                ch_a = True
 
752
                lines_b.append(line)
 
753
            elif state == 'killed-b':
 
754
                ch_b = True
 
755
                lines_a.append(line)
 
756
            elif state == 'new-a':
 
757
                ch_a = True
 
758
                lines_a.append(line)
 
759
            elif state == 'new-b':
 
760
                ch_b = True
 
761
                lines_b.append(line)
 
762
            else:
 
763
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
 
764
                                 'killed-both'), \
 
765
                       state
 
766
 
 
767
                
 
768
 
 
769
 
 
770
 
1218
771
 
1219
772
 
1220
773
def weave_toc(w):
1223
776
    for i in (6, 50, 10, 10):
1224
777
        print '-' * i,
1225
778
    print
1226
 
    for i in range(w.num_versions()):
 
779
    for i in range(w.numversions()):
1227
780
        sha1 = w._sha1s[i]
1228
781
        name = w._names[i]
1229
782
        parent_str = ' '.join(map(str, w._parents[i]))
1231
784
 
1232
785
 
1233
786
 
1234
 
def weave_stats(weave_file, pb):
 
787
def weave_stats(weave_file):
 
788
    from bzrlib.progress import ProgressBar
1235
789
    from bzrlib.weavefile import read_weave
1236
790
 
 
791
    pb = ProgressBar()
 
792
 
1237
793
    wf = file(weave_file, 'rb')
1238
794
    w = read_weave(wf)
1239
795
    # FIXME: doesn't work on pipes
1243
799
    vers = len(w)
1244
800
    for i in range(vers):
1245
801
        pb.update('checking sizes', i, vers)
1246
 
        for origin, lineno, line in w._extract([i]):
 
802
        for line in w.get_iter(i):
1247
803
            total += len(line)
1248
804
 
1249
805
    pb.clear()
1276
832
        Add NEWTEXT, with specified parent versions.
1277
833
    weave annotate WEAVEFILE VERSION
1278
834
        Display origin of each line.
 
835
    weave mash WEAVEFILE VERSION...
 
836
        Display composite of all selected versions.
1279
837
    weave merge WEAVEFILE VERSION1 VERSION2 > OUT
1280
838
        Auto-merge two versions and display conflicts.
1281
839
    weave diff WEAVEFILE VERSION1 VERSION2 
1310
868
def main(argv):
1311
869
    import sys
1312
870
    import os
1313
 
    try:
1314
 
        import bzrlib
1315
 
    except ImportError:
1316
 
        # in case we're run directly from the subdirectory
1317
 
        sys.path.append('..')
1318
 
        import bzrlib
1319
871
    from bzrlib.weavefile import write_weave, read_weave
1320
872
    from bzrlib.progress import ProgressBar
1321
873
 
1355
907
        w = readit()
1356
908
        sys.stdout.writelines(w.get_iter(int(argv[3])))
1357
909
        
 
910
    elif cmd == 'mash': # get composite
 
911
        w = readit()
 
912
        sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
 
913
 
1358
914
    elif cmd == 'diff':
 
915
        from difflib import unified_diff
1359
916
        w = readit()
1360
917
        fn = argv[2]
1361
918
        v1, v2 = map(int, argv[3:5])
1362
919
        lines1 = w.get(v1)
1363
920
        lines2 = w.get(v2)
1364
 
        diff_gen = bzrlib.patiencediff.unified_diff(lines1, lines2,
 
921
        diff_gen = unified_diff(lines1, lines2,
1365
922
                                '%s version %d' % (fn, v1),
1366
923
                                '%s version %d' % (fn, v2))
1367
924
        sys.stdout.writelines(diff_gen)
1383
940
        weave_toc(readit())
1384
941
 
1385
942
    elif cmd == 'stats':
1386
 
        weave_stats(argv[2], ProgressBar())
 
943
        weave_stats(argv[2])
1387
944
        
1388
945
    elif cmd == 'check':
1389
946
        w = readit()
1390
947
        pb = ProgressBar()
1391
948
        w.check(pb)
1392
949
        pb.clear()
1393
 
        print '%d versions ok' % w.num_versions()
 
950
        print '%d versions ok' % w.numversions()
1394
951
 
1395
952
    elif cmd == 'inclusions':
1396
953
        w = readit()
1401
958
        print ' '.join(map(str, w._parents[int(argv[3])]))
1402
959
 
1403
960
    elif cmd == 'plan-merge':
1404
 
        # replaced by 'bzr weave-plan-merge'
1405
961
        w = readit()
1406
962
        for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
1407
963
            if line:
1408
964
                print '%14s | %s' % (state, line),
 
965
 
1409
966
    elif cmd == 'merge':
1410
 
        # replaced by 'bzr weave-merge-text'
1411
967
        w = readit()
1412
968
        p = w.plan_merge(int(argv[3]), int(argv[4]))
1413
969
        sys.stdout.writelines(w.weave_merge(p))
 
970
            
 
971
    elif cmd == 'mash-merge':
 
972
        if len(argv) != 5:
 
973
            usage()
 
974
            return 1
 
975
 
 
976
        w = readit()
 
977
        v1, v2 = map(int, argv[3:5])
 
978
 
 
979
        basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
 
980
 
 
981
        base_lines = list(w.mash_iter(basis))
 
982
        a_lines = list(w.get(v1))
 
983
        b_lines = list(w.get(v2))
 
984
 
 
985
        from bzrlib.merge3 import Merge3
 
986
        m3 = Merge3(base_lines, a_lines, b_lines)
 
987
 
 
988
        name_a = 'version %d' % v1
 
989
        name_b = 'version %d' % v2
 
990
        sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
1414
991
    else:
1415
992
        raise ValueError('unknown command %r' % cmd)
1416
993
    
1417
994
 
 
995
 
 
996
def profile_main(argv): 
 
997
    import tempfile, hotshot, hotshot.stats
 
998
 
 
999
    prof_f = tempfile.NamedTemporaryFile()
 
1000
 
 
1001
    prof = hotshot.Profile(prof_f.name)
 
1002
 
 
1003
    ret = prof.runcall(main, argv)
 
1004
    prof.close()
 
1005
 
 
1006
    stats = hotshot.stats.load(prof_f.name)
 
1007
    #stats.strip_dirs()
 
1008
    stats.sort_stats('cumulative')
 
1009
    ## XXX: Might like to write to stderr or the trace file instead but
 
1010
    ## print_stats seems hardcoded to stdout
 
1011
    stats.print_stats(20)
 
1012
            
 
1013
    return ret
 
1014
 
 
1015
 
1418
1016
if __name__ == '__main__':
1419
1017
    import sys
1420
 
    sys.exit(main(sys.argv))
1421
 
 
1422
 
 
1423
 
class InterWeave(InterVersionedFile):
1424
 
    """Optimised code paths for weave to weave operations."""
1425
 
    
1426
 
    _matching_file_from_factory = staticmethod(WeaveFile)
1427
 
    _matching_file_to_factory = staticmethod(WeaveFile)
1428
 
    
1429
 
    @staticmethod
1430
 
    def is_compatible(source, target):
1431
 
        """Be compatible with weaves."""
1432
 
        try:
1433
 
            return (isinstance(source, Weave) and
1434
 
                    isinstance(target, Weave))
1435
 
        except AttributeError:
1436
 
            return False
1437
 
 
1438
 
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
1439
 
        """See InterVersionedFile.join."""
1440
 
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
1441
 
        if self.target.versions() == [] and version_ids is None:
1442
 
            self.target._copy_weave_content(self.source)
1443
 
            return
1444
 
        try:
1445
 
            self.target._join(self.source, pb, msg, version_ids, ignore_missing)
1446
 
        except errors.WeaveParentMismatch:
1447
 
            self.target._reweave(self.source, pb, msg)
1448
 
 
1449
 
 
1450
 
InterVersionedFile.register_optimiser(InterWeave)
 
1018
    if '--profile' in sys.argv:
 
1019
        args = sys.argv[:]
 
1020
        args.remove('--profile')
 
1021
        sys.exit(profile_main(args))
 
1022
    else:
 
1023
        sys.exit(main(sys.argv))
 
1024