← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

  • Committer: Robert Collins
  • Date: 2007-09-12 04:21:51 UTC
  • mto: This revision was merged to the branch mainline in revision 2817.
  • Revision ID: robertc@robertcollins.net-20070912042151-o2k78pnf1hdwd2xt
Review feedback.

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?
55
24
 
56
25
# XXX: If we do weaves this way, will a merge still behave the same
57
26
# way if it's done in a different order?  That's a pretty desirable
58
27
# property.
59
28
 
60
29
# TODO: Nothing here so far assumes the lines are really \n newlines,
61
 
# rather than being split up in some other way.  We could accomodate
 
30
# rather than being split up in some other way.  We could accommodate
62
31
# binaries, perhaps by naively splitting on \n or perhaps using
63
32
# something like a rolling checksum.
64
33
 
74
43
 
75
44
# TODO: Parallel-extract that passes back each line along with a
76
45
# description of which revisions include it.  Nice for checking all
77
 
# shas in parallel.
 
46
# shas or calculating stats in parallel.
78
47
 
79
48
# TODO: Using a single _extract routine and then processing the output
80
49
# is probably inefficient.  It's simple enough that we can afford to
81
50
# have slight specializations for different ways its used: annotate,
82
51
# basis for add, get, etc.
83
52
 
84
 
# TODO: Perhaps the API should work only in names to hide the integer
85
 
# indexes from the user?
86
 
 
87
 
 
88
 
 
 
53
# TODO: Probably the API should work only in names to hide the integer
 
54
# indexes from the user.
 
55
 
 
56
# TODO: Is there any potential performance win by having an add()
 
57
# variant that is passed a pre-cooked version of the single basis
 
58
# version?
 
59
 
 
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
 
72
from cStringIO import StringIO
 
73
import os
89
74
import sha
90
 
from cStringIO import StringIO
91
 
 
92
 
 
93
 
class WeaveError(Exception):
94
 
    """Exception in processing weave"""
95
 
 
96
 
 
97
 
class WeaveFormatError(WeaveError):
98
 
    """Weave invariant violated"""
99
 
    
100
 
 
101
 
class Weave(object):
 
75
import time
 
76
import warnings
 
77
 
 
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
from bzrlib.osutils import sha_strings
 
90
import bzrlib.patiencediff
 
91
from bzrlib.tsort import topo_sort
 
92
from bzrlib.versionedfile import VersionedFile, InterVersionedFile
 
93
from bzrlib.weavefile import _read_weave_v5, write_weave_v5
 
94
 
 
95
 
 
96
class Weave(VersionedFile):
102
97
    """weave - versioned text file storage.
103
98
    
104
99
    A Weave manages versions of line-based text files, keeping track
113
108
 
114
109
    * a nonnegative index number.
115
110
 
116
 
    * a version-id string. (not implemented yet)
 
111
    * a version-id string.
117
112
 
118
113
    Typically the index number will be valid only inside this weave and
119
114
    the version-id is used to reference it in the larger world.
188
183
    """
189
184
 
190
185
    __slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
191
 
                 '_weave_name']
 
186
                 '_weave_name', '_matcher']
192
187
    
193
 
    def __init__(self, weave_name=None):
 
188
    def __init__(self, weave_name=None, access_mode='w', matcher=None):
 
189
        super(Weave, self).__init__(access_mode)
194
190
        self._weave = []
195
191
        self._parents = []
196
192
        self._sha1s = []
197
193
        self._names = []
198
194
        self._name_map = {}
199
195
        self._weave_name = weave_name
200
 
 
 
196
        if matcher is None:
 
197
            self._matcher = bzrlib.patiencediff.PatienceSequenceMatcher
 
198
        else:
 
199
            self._matcher = matcher
 
200
 
 
201
    def __repr__(self):
 
202
        return "Weave(%r)" % self._weave_name
 
203
 
 
204
    def copy(self):
 
205
        """Return a deep copy of self.
 
206
        
 
207
        The copy can be modified without affecting the original weave."""
 
208
        other = Weave()
 
209
        other._weave = self._weave[:]
 
210
        other._parents = self._parents[:]
 
211
        other._sha1s = self._sha1s[:]
 
212
        other._names = self._names[:]
 
213
        other._name_map = self._name_map.copy()
 
214
        other._weave_name = self._weave_name
 
215
        return other
201
216
 
202
217
    def __eq__(self, other):
203
218
        if not isinstance(other, Weave):
205
220
        return self._parents == other._parents \
206
221
               and self._weave == other._weave \
207
222
               and self._sha1s == other._sha1s 
208
 
 
209
223
    
210
224
    def __ne__(self, other):
211
225
        return not self.__eq__(other)
212
226
 
 
227
    def _idx_to_name(self, version):
 
228
        return self._names[version]
213
229
 
214
 
    def lookup(self, name):
 
230
    def _lookup(self, name):
 
231
        """Convert symbolic version name to index."""
 
232
        self.check_not_reserved_id(name)
215
233
        try:
216
234
            return self._name_map[name]
217
235
        except KeyError:
218
 
            raise WeaveError("name %s not present in weave %s" %
219
 
                             (name, self._weave_name))
220
 
 
221
 
        
222
 
    def add(self, name, parents, text):
 
236
            raise RevisionNotPresent(name, self._weave_name)
 
237
 
 
238
    def versions(self):
 
239
        """See VersionedFile.versions."""
 
240
        return self._names[:]
 
241
 
 
242
    def has_version(self, version_id):
 
243
        """See VersionedFile.has_version."""
 
244
        return (version_id in self._name_map)
 
245
 
 
246
    __contains__ = has_version
 
247
 
 
248
    def get_parents(self, version_id):
 
249
        """See VersionedFile.get_parent."""
 
250
        return map(self._idx_to_name, self._parents[self._lookup(version_id)])
 
251
 
 
252
    def _check_repeated_add(self, name, parents, text, sha1):
 
253
        """Check that a duplicated add is OK.
 
254
 
 
255
        If it is, return the (old) index; otherwise raise an exception.
 
256
        """
 
257
        idx = self._lookup(name)
 
258
        if sorted(self._parents[idx]) != sorted(parents) \
 
259
            or sha1 != self._sha1s[idx]:
 
260
            raise RevisionAlreadyPresent(name, self._weave_name)
 
261
        return idx
 
262
 
 
263
    def _add_lines(self, version_id, parents, lines, parent_texts,
 
264
       left_matching_blocks, nostore_sha, random_id, check_content):
 
265
        """See VersionedFile.add_lines."""
 
266
        idx = self._add(version_id, lines, map(self._lookup, parents),
 
267
            nostore_sha=nostore_sha)
 
268
        return sha_strings(lines), sum(map(len, lines)), idx
 
269
 
 
270
    def _add(self, version_id, lines, parents, sha1=None, nostore_sha=None):
223
271
        """Add a single text on top of the weave.
224
272
  
225
273
        Returns the index number of the newly added version.
226
274
 
227
 
        name
 
275
        version_id
228
276
            Symbolic name for this version.
229
277
            (Typically the revision-id of the revision that added it.)
230
278
 
231
279
        parents
232
280
            List or set of direct parent version numbers.
233
281
            
234
 
        text
235
 
            Sequence of lines to be added in the new version."""
236
 
 
237
 
        assert isinstance(name, basestring)
238
 
        if name in self._name_map:
239
 
            raise WeaveError("name %r already present in weave" % name)
240
 
        
 
282
        lines
 
283
            Sequence of lines to be added in the new version.
 
284
 
 
285
        :param nostore_sha: See VersionedFile.add_lines.
 
286
        """
 
287
        assert isinstance(version_id, basestring)
 
288
        self._check_lines_not_unicode(lines)
 
289
        self._check_lines_are_lines(lines)
 
290
        if not sha1:
 
291
            sha1 = sha_strings(lines)
 
292
        if sha1 == nostore_sha:
 
293
            raise errors.ExistingContent
 
294
        if version_id in self._name_map:
 
295
            return self._check_repeated_add(version_id, parents, lines, sha1)
 
296
 
241
297
        self._check_versions(parents)
242
 
        ## self._check_lines(text)
 
298
        ## self._check_lines(lines)
243
299
        new_version = len(self._parents)
244
300
 
245
 
        s = sha.new()
246
 
        map(s.update, text)
247
 
        sha1 = s.hexdigest()
248
 
        del s
249
 
 
250
301
        # if we abort after here the (in-memory) weave will be corrupt because only
251
302
        # some fields are updated
 
303
        # XXX: FIXME implement a succeed-or-fail of the rest of this routine.
 
304
        #      - Robert Collins 20060226
252
305
        self._parents.append(parents[:])
253
306
        self._sha1s.append(sha1)
254
 
        self._names.append(name)
255
 
        self._name_map[name] = new_version
 
307
        self._names.append(version_id)
 
308
        self._name_map[version_id] = new_version
256
309
 
257
310
            
258
311
        if not parents:
260
313
            # this more quickly by just appending unconditionally.
261
314
            # even more specially, if we're adding an empty text we
262
315
            # need do nothing at all.
263
 
            if text:
 
316
            if lines:
264
317
                self._weave.append(('{', new_version))
265
 
                self._weave.extend(text)
 
318
                self._weave.extend(lines)
266
319
                self._weave.append(('}', None))
267
 
        
268
320
            return new_version
269
321
 
270
322
        if len(parents) == 1:
274
326
                return new_version
275
327
            
276
328
 
277
 
        ancestors = self.inclusions(parents)
 
329
        ancestors = self._inclusions(parents)
278
330
 
279
331
        l = self._weave
280
332
 
287
339
 
288
340
        # another small special case: a merge, producing the same text
289
341
        # as auto-merge
290
 
        if text == basis_lines:
291
 
            return new_version            
 
342
        if lines == basis_lines:
 
343
            return new_version
292
344
 
293
 
        # add a sentinal, because we can also match against the final line
 
345
        # add a sentinel, because we can also match against the final line
294
346
        basis_lineno.append(len(self._weave))
295
347
 
296
348
        # XXX: which line of the weave should we really consider
300
352
        #print 'basis_lines:', basis_lines
301
353
        #print 'new_lines:  ', lines
302
354
 
303
 
        from difflib import SequenceMatcher
304
 
        s = SequenceMatcher(None, basis_lines, text)
 
355
        s = self._matcher(None, basis_lines, lines)
305
356
 
306
357
        # offset gives the number of lines that have been inserted
307
358
        # into the weave up to the current point; if the original edit instruction
318
369
            i1 = basis_lineno[i1]
319
370
            i2 = basis_lineno[i2]
320
371
 
321
 
            assert 0 <= j1 <= j2 <= len(text)
 
372
            assert 0 <= j1 <= j2 <= len(lines)
322
373
 
323
374
            #print tag, i1, i2, j1, j2
324
375
 
335
386
                # we don't destroy ourselves
336
387
                i = i2 + offset
337
388
                self._weave[i:i] = ([('{', new_version)] 
338
 
                                    + text[j1:j2] 
 
389
                                    + lines[j1:j2] 
339
390
                                    + [('}', None)])
340
391
                offset += 2 + (j2 - j1)
341
 
 
342
392
        return new_version
343
393
 
 
394
    def _clone_text(self, new_version_id, old_version_id, parents):
 
395
        """See VersionedFile.clone_text."""
 
396
        old_lines = self.get_text(old_version_id)
 
397
        self.add_lines(new_version_id, parents, old_lines)
344
398
 
345
 
    def inclusions(self, versions):
 
399
    def _inclusions(self, versions):
346
400
        """Return set of all ancestors of given version(s)."""
 
401
        if not len(versions):
 
402
            return []
347
403
        i = set(versions)
348
 
        v = max(versions)
349
 
        try:
350
 
            while v >= 0:
351
 
                if v in i:
352
 
                    # include all its parents
353
 
                    i.update(self._parents[v])
354
 
                v -= 1
355
 
            return i
356
 
        except IndexError:
357
 
            raise ValueError("version %d not present in weave" % v)
358
 
 
359
 
 
360
 
    def minimal_parents(self, version):
361
 
        """Find the minimal set of parents for the version."""
362
 
        included = self._parents[version]
363
 
        if not included:
364
 
            return []
365
 
        
366
 
        li = list(included)
367
 
        li.sort(reverse=True)
368
 
 
369
 
        mininc = []
370
 
        gotit = set()
371
 
 
372
 
        for pv in li:
373
 
            if pv not in gotit:
374
 
                mininc.append(pv)
375
 
                gotit.update(self.inclusions(pv))
376
 
 
377
 
        assert mininc[0] >= 0
378
 
        assert mininc[-1] < version
379
 
        return mininc
380
 
 
381
 
 
 
404
        for v in xrange(max(versions), 0, -1):
 
405
            if v in i:
 
406
                # include all its parents
 
407
                i.update(self._parents[v])
 
408
        return i
 
409
        ## except IndexError:
 
410
        ##     raise ValueError("version %d not present in weave" % v)
 
411
 
 
412
    def get_ancestry(self, version_ids, topo_sorted=True):
 
413
        """See VersionedFile.get_ancestry."""
 
414
        if isinstance(version_ids, basestring):
 
415
            version_ids = [version_ids]
 
416
        i = self._inclusions([self._lookup(v) for v in version_ids])
 
417
        return [self._idx_to_name(v) for v in i]
382
418
 
383
419
    def _check_lines(self, text):
384
420
        if not isinstance(text, list):
399
435
            except IndexError:
400
436
                raise IndexError("invalid version number %r" % i)
401
437
 
402
 
    
403
 
    def annotate(self, index):
404
 
        return list(self.annotate_iter(index))
405
 
 
406
 
 
407
 
    def annotate_iter(self, version):
408
 
        """Yield list of (index-id, line) pairs for the specified version.
 
438
    def _compatible_parents(self, my_parents, other_parents):
 
439
        """During join check that other_parents are joinable with my_parents.
 
440
 
 
441
        Joinable is defined as 'is a subset of' - supersets may require 
 
442
        regeneration of diffs, but subsets do not.
 
443
        """
 
444
        return len(other_parents.difference(my_parents)) == 0
 
445
 
 
446
    def annotate_iter(self, version_id):
 
447
        """Yield list of (version-id, line) pairs for the specified version.
409
448
 
410
449
        The index indicates when the line originated in the weave."""
411
 
        for origin, lineno, text in self._extract([version]):
412
 
            yield origin, text
413
 
 
414
 
 
415
 
    def _walk(self):
416
 
        """Walk the weave.
417
 
 
418
 
        Yields sequence of
419
 
        (lineno, insert, deletes, text)
420
 
        for each literal line.
421
 
        """
 
450
        incls = [self._lookup(version_id)]
 
451
        for origin, lineno, text in self._extract(incls):
 
452
            yield self._idx_to_name(origin), text
 
453
 
 
454
    def iter_lines_added_or_present_in_versions(self, version_ids=None,
 
455
                                                pb=None):
 
456
        """See VersionedFile.iter_lines_added_or_present_in_versions()."""
 
457
        if version_ids is None:
 
458
            version_ids = self.versions()
 
459
        version_ids = set(version_ids)
 
460
        for lineno, inserted, deletes, line in self._walk_internal(version_ids):
 
461
            # if inserted not in version_ids then it was inserted before the
 
462
            # versions we care about, but because weaves cannot represent ghosts
 
463
            # properly, we do not filter down to that
 
464
            # if inserted not in version_ids: continue
 
465
            if line[-1] != '\n':
 
466
                yield line + '\n'
 
467
            else:
 
468
                yield line
 
469
 
 
470
    def _walk_internal(self, version_ids=None):
 
471
        """Helper method for weave actions."""
422
472
        
423
473
        istack = []
424
474
        dset = set()
426
476
        lineno = 0         # line of weave, 0-based
427
477
 
428
478
        for l in self._weave:
429
 
            if isinstance(l, tuple):
 
479
            if l.__class__ == tuple:
430
480
                c, v = l
431
481
                isactive = None
432
482
                if c == '{':
433
 
                    istack.append(v)
 
483
                    istack.append(self._names[v])
434
484
                elif c == '}':
435
485
                    istack.pop()
436
486
                elif c == '[':
437
 
                    assert v not in dset
438
 
                    dset.add(v)
 
487
                    assert self._names[v] not in dset
 
488
                    dset.add(self._names[v])
439
489
                elif c == ']':
440
 
                    dset.remove(v)
 
490
                    dset.remove(self._names[v])
441
491
                else:
442
 
                    raise WeaveFormatError('unexpected instruction %r'
443
 
                                           % v)
 
492
                    raise WeaveFormatError('unexpected instruction %r' % v)
444
493
            else:
445
 
                assert isinstance(l, basestring)
 
494
                assert l.__class__ in (str, unicode)
446
495
                assert istack
447
 
                yield lineno, istack[-1], dset, l
 
496
                yield lineno, istack[-1], frozenset(dset), l
448
497
            lineno += 1
449
498
 
450
 
 
 
499
        if istack:
 
500
            raise WeaveFormatError("unclosed insertion blocks "
 
501
                    "at end of weave: %s" % istack)
 
502
        if dset:
 
503
            raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
 
504
                                   % dset)
 
505
 
 
506
    def plan_merge(self, ver_a, ver_b):
 
507
        """Return pseudo-annotation indicating how the two versions merge.
 
508
 
 
509
        This is computed between versions a and b and their common
 
510
        base.
 
511
 
 
512
        Weave lines present in none of them are skipped entirely.
 
513
        """
 
514
        inc_a = set(self.get_ancestry([ver_a]))
 
515
        inc_b = set(self.get_ancestry([ver_b]))
 
516
        inc_c = inc_a & inc_b
 
517
 
 
518
        for lineno, insert, deleteset, line in self._walk_internal([ver_a, ver_b]):
 
519
            if deleteset & inc_c:
 
520
                # killed in parent; can't be in either a or b
 
521
                # not relevant to our work
 
522
                yield 'killed-base', line
 
523
            elif insert in inc_c:
 
524
                # was inserted in base
 
525
                killed_a = bool(deleteset & inc_a)
 
526
                killed_b = bool(deleteset & inc_b)
 
527
                if killed_a and killed_b:
 
528
                    yield 'killed-both', line
 
529
                elif killed_a:
 
530
                    yield 'killed-a', line
 
531
                elif killed_b:
 
532
                    yield 'killed-b', line
 
533
                else:
 
534
                    yield 'unchanged', line
 
535
            elif insert in inc_a:
 
536
                if deleteset & inc_a:
 
537
                    yield 'ghost-a', line
 
538
                else:
 
539
                    # new in A; not in B
 
540
                    yield 'new-a', line
 
541
            elif insert in inc_b:
 
542
                if deleteset & inc_b:
 
543
                    yield 'ghost-b', line
 
544
                else:
 
545
                    yield 'new-b', line
 
546
            else:
 
547
                # not in either revision
 
548
                yield 'irrelevant', line
 
549
 
 
550
        yield 'unchanged', ''           # terminator
451
551
 
452
552
    def _extract(self, versions):
453
553
        """Yield annotation of lines in included set.
462
562
            if not isinstance(i, int):
463
563
                raise ValueError(i)
464
564
            
465
 
        included = self.inclusions(versions)
 
565
        included = self._inclusions(versions)
466
566
 
467
567
        istack = []
 
568
        iset = set()
468
569
        dset = set()
469
570
 
470
571
        lineno = 0         # line of weave, 0-based
475
576
 
476
577
        WFE = WeaveFormatError
477
578
 
 
579
        # wow. 
 
580
        #  449       0   4474.6820   2356.5590   bzrlib.weave:556(_extract)
 
581
        #  +285282   0   1676.8040   1676.8040   +<isinstance>
 
582
        # 1.6 seconds in 'isinstance'.
 
583
        # changing the first isinstance:
 
584
        #  449       0   2814.2660   1577.1760   bzrlib.weave:556(_extract)
 
585
        #  +140414   0    762.8050    762.8050   +<isinstance>
 
586
        # note that the inline time actually dropped (less function calls)
 
587
        # and total processing time was halved.
 
588
        # we're still spending ~1/4 of the method in isinstance though.
 
589
        # so lets hard code the acceptable string classes we expect:
 
590
        #  449       0   1202.9420    786.2930   bzrlib.weave:556(_extract)
 
591
        # +71352     0    377.5560    377.5560   +<method 'append' of 'list' 
 
592
        #                                          objects>
 
593
        # yay, down to ~1/4 the initial extract time, and our inline time
 
594
        # has shrunk again, with isinstance no longer dominating.
 
595
        # tweaking the stack inclusion test to use a set gives:
 
596
        #  449       0   1122.8030    713.0080   bzrlib.weave:556(_extract)
 
597
        # +71352     0    354.9980    354.9980   +<method 'append' of 'list' 
 
598
        #                                          objects>
 
599
        # - a 5% win, or possibly just noise. However with large istacks that
 
600
        # 'in' test could dominate, so I'm leaving this change in place -
 
601
        # when its fast enough to consider profiling big datasets we can review.
 
602
 
 
603
              
 
604
             
 
605
 
478
606
        for l in self._weave:
479
 
            if isinstance(l, tuple):
 
607
            if l.__class__ == tuple:
480
608
                c, v = l
481
609
                isactive = None
482
610
                if c == '{':
483
 
                    assert v not in istack
 
611
                    assert v not in iset
484
612
                    istack.append(v)
 
613
                    iset.add(v)
485
614
                elif c == '}':
486
 
                    istack.pop()
 
615
                    iset.remove(istack.pop())
487
616
                elif c == '[':
488
617
                    if v in included:
489
618
                        assert v not in dset
494
623
                        assert v in dset
495
624
                        dset.remove(v)
496
625
            else:
497
 
                assert isinstance(l, basestring)
 
626
                assert l.__class__ in (str, unicode)
498
627
                if isactive is None:
499
628
                    isactive = (not dset) and istack and (istack[-1] in included)
500
629
                if isactive:
501
630
                    result.append((istack[-1], lineno, l))
502
631
            lineno += 1
503
 
 
504
632
        if istack:
505
 
            raise WFE("unclosed insertion blocks at end of weave",
506
 
                                   istack)
 
633
            raise WeaveFormatError("unclosed insertion blocks "
 
634
                    "at end of weave: %s" % istack)
507
635
        if dset:
508
 
            raise WFE("unclosed deletion blocks at end of weave",
509
 
                                   dset)
510
 
 
511
 
        return result
512
 
    
513
 
 
514
 
 
515
 
    def get_iter(self, version):
516
 
        """Yield lines for the specified version."""
517
 
        for origin, lineno, line in self._extract([version]):
518
 
            yield line
519
 
 
520
 
 
521
 
    def get_text(self, version):
522
 
        assert isinstance(version, int)
523
 
        s = StringIO()
524
 
        s.writelines(self.get_iter(version))
525
 
        return s.getvalue()
526
 
 
527
 
 
528
 
    def get(self, index):
529
 
        return list(self.get_iter(index))
530
 
 
531
 
 
532
 
    def mash_iter(self, included):
533
 
        """Return composed version of multiple included versions."""
534
 
        for origin, lineno, text in self._extract(included):
535
 
            yield text
536
 
 
537
 
 
538
 
    def dump(self, to_file):
539
 
        from pprint import pprint
540
 
        print >>to_file, "Weave._weave = ",
541
 
        pprint(self._weave, to_file)
542
 
        print >>to_file, "Weave._parents = ",
543
 
        pprint(self._parents, to_file)
544
 
 
545
 
 
546
 
 
547
 
    def numversions(self):
 
636
            raise WeaveFormatError("unclosed deletion blocks at end of weave: %s"
 
637
                                   % dset)
 
638
        return result
 
639
 
 
640
    def _maybe_lookup(self, name_or_index):
 
641
        """Convert possible symbolic name to index, or pass through indexes.
 
642
        
 
643
        NOT FOR PUBLIC USE.
 
644
        """
 
645
        if isinstance(name_or_index, (int, long)):
 
646
            return name_or_index
 
647
        else:
 
648
            return self._lookup(name_or_index)
 
649
 
 
650
    def get_lines(self, version_id):
 
651
        """See VersionedFile.get_lines()."""
 
652
        int_index = self._maybe_lookup(version_id)
 
653
        result = [line for (origin, lineno, line) in self._extract([int_index])]
 
654
        expected_sha1 = self._sha1s[int_index]
 
655
        measured_sha1 = sha_strings(result)
 
656
        if measured_sha1 != expected_sha1:
 
657
            raise errors.WeaveInvalidChecksum(
 
658
                    'file %s, revision %s, expected: %s, measured %s' 
 
659
                    % (self._weave_name, version_id,
 
660
                       expected_sha1, measured_sha1))
 
661
        return result
 
662
 
 
663
    def get_sha1(self, version_id):
 
664
        """See VersionedFile.get_sha1()."""
 
665
        return self._sha1s[self._lookup(version_id)]
 
666
 
 
667
    def get_sha1s(self, version_ids):
 
668
        """See VersionedFile.get_sha1s()."""
 
669
        return [self._sha1s[self._lookup(v)] for v in version_ids]
 
670
 
 
671
    def num_versions(self):
 
672
        """How many versions are in this weave?"""
548
673
        l = len(self._parents)
549
674
        assert l == len(self._sha1s)
550
675
        return l
551
676
 
552
 
 
553
 
    def __len__(self):
554
 
        return self.numversions()
555
 
 
 
677
    __len__ = num_versions
556
678
 
557
679
    def check(self, progress_bar=None):
558
 
        # check no circular inclusions
559
 
        for version in range(self.numversions()):
 
680
        # TODO evaluate performance hit of using string sets in this routine.
 
681
        # TODO: check no circular inclusions
 
682
        # TODO: create a nested progress bar
 
683
        for version in range(self.num_versions()):
560
684
            inclusions = list(self._parents[version])
561
685
            if inclusions:
562
686
                inclusions.sort()
564
688
                    raise WeaveFormatError("invalid included version %d for index %d"
565
689
                                           % (inclusions[-1], version))
566
690
 
567
 
        # try extracting all versions; this is a bit slow and parallel
568
 
        # extraction could be used
569
 
        nv = self.numversions()
570
 
        for version in range(nv):
 
691
        # try extracting all versions; parallel extraction is used
 
692
        nv = self.num_versions()
 
693
        sha1s = {}
 
694
        texts = {}
 
695
        inclusions = {}
 
696
        for i in range(nv):
 
697
            # For creating the ancestry, IntSet is much faster (3.7s vs 0.17s)
 
698
            # The problem is that set membership is much more expensive
 
699
            name = self._idx_to_name(i)
 
700
            sha1s[name] = sha.new()
 
701
            texts[name] = []
 
702
            new_inc = set([name])
 
703
            for p in self._parents[i]:
 
704
                new_inc.update(inclusions[self._idx_to_name(p)])
 
705
 
 
706
            assert set(new_inc) == set(self.get_ancestry(name)), \
 
707
                'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
 
708
            inclusions[name] = new_inc
 
709
 
 
710
        nlines = len(self._weave)
 
711
 
 
712
        update_text = 'checking weave'
 
713
        if self._weave_name:
 
714
            short_name = os.path.basename(self._weave_name)
 
715
            update_text = 'checking %s' % (short_name,)
 
716
            update_text = update_text[:25]
 
717
 
 
718
        for lineno, insert, deleteset, line in self._walk_internal():
571
719
            if progress_bar:
572
 
                progress_bar.update('checking text', version, nv)
573
 
            s = sha.new()
574
 
            for l in self.get_iter(version):
575
 
                s.update(l)
576
 
            hd = s.hexdigest()
577
 
            expected = self._sha1s[version]
 
720
                progress_bar.update(update_text, lineno, nlines)
 
721
 
 
722
            for name, name_inclusions in inclusions.items():
 
723
                # The active inclusion must be an ancestor,
 
724
                # and no ancestors must have deleted this line,
 
725
                # because we don't support resurrection.
 
726
                if (insert in name_inclusions) and not (deleteset & name_inclusions):
 
727
                    sha1s[name].update(line)
 
728
 
 
729
        for i in range(nv):
 
730
            version = self._idx_to_name(i)
 
731
            hd = sha1s[version].hexdigest()
 
732
            expected = self._sha1s[i]
578
733
            if hd != expected:
579
 
                raise WeaveError("mismatched sha1 for version %d; "
580
 
                                 "got %s, expected %s"
581
 
                                 % (version, hd, expected))
 
734
                raise errors.WeaveInvalidChecksum(
 
735
                        "mismatched sha1 for version %s: "
 
736
                        "got %s, expected %s"
 
737
                        % (version, hd, expected))
582
738
 
583
739
        # TODO: check insertions are properly nested, that there are
584
740
        # no lines outside of insertion blocks, that deletions are
585
741
        # properly paired, etc.
586
742
 
587
 
 
588
 
 
589
 
    def merge(self, merge_versions):
590
 
        """Automerge and mark conflicts between versions.
591
 
 
592
 
        This returns a sequence, each entry describing alternatives
593
 
        for a chunk of the file.  Each of the alternatives is given as
594
 
        a list of lines.
595
 
 
596
 
        If there is a chunk of the file where there's no diagreement,
597
 
        only one alternative is given.
598
 
        """
599
 
 
600
 
        # approach: find the included versions common to all the
601
 
        # merged versions
602
 
        raise NotImplementedError()
603
 
 
604
 
 
605
 
 
606
 
    def _delta(self, included, lines):
607
 
        """Return changes from basis to new revision.
608
 
 
609
 
        The old text for comparison is the union of included revisions.
610
 
 
611
 
        This is used in inserting a new text.
612
 
 
613
 
        Delta is returned as a sequence of
614
 
        (weave1, weave2, newlines).
615
 
 
616
 
        This indicates that weave1:weave2 of the old weave should be
617
 
        replaced by the sequence of lines in newlines.  Note that
618
 
        these line numbers are positions in the total weave and don't
619
 
        correspond to the lines in any extracted version, or even the
620
 
        extracted union of included versions.
621
 
 
622
 
        If line1=line2, this is a pure insert; if newlines=[] this is a
623
 
        pure delete.  (Similar to difflib.)
624
 
        """
625
 
 
626
 
 
627
 
            
628
 
    def plan_merge(self, ver_a, ver_b):
629
 
        """Return pseudo-annotation indicating how the two versions merge.
630
 
 
631
 
        This is computed between versions a and b and their common
632
 
        base.
633
 
 
634
 
        Weave lines present in none of them are skipped entirely.
635
 
        """
636
 
        inc_a = self.inclusions([ver_a])
637
 
        inc_b = self.inclusions([ver_b])
638
 
        inc_c = inc_a & inc_b
639
 
 
640
 
        for lineno, insert, deleteset, line in self._walk():
641
 
            if deleteset & inc_c:
642
 
                # killed in parent; can't be in either a or b
643
 
                # not relevant to our work
644
 
                yield 'killed-base', line
645
 
            elif insert in inc_c:
646
 
                # was inserted in base
647
 
                killed_a = bool(deleteset & inc_a)
648
 
                killed_b = bool(deleteset & inc_b)
649
 
                if killed_a and killed_b:
650
 
                    yield 'killed-both', line
651
 
                elif killed_a:
652
 
                    yield 'killed-a', line
653
 
                elif killed_b:
654
 
                    yield 'killed-b', line
655
 
                else:
656
 
                    yield 'unchanged', line
657
 
            elif insert in inc_a:
658
 
                if deleteset & inc_a:
659
 
                    yield 'ghost-a', line
660
 
                else:
661
 
                    # new in A; not in B
662
 
                    yield 'new-a', line
663
 
            elif insert in inc_b:
664
 
                if deleteset & inc_b:
665
 
                    yield 'ghost-b', line
666
 
                else:
667
 
                    yield 'new-b', line
668
 
            else:
669
 
                # not in either revision
670
 
                yield 'irrelevant', line
671
 
 
672
 
        yield 'unchanged', ''           # terminator
673
 
 
674
 
 
675
 
 
676
 
    def weave_merge(self, plan):
677
 
        lines_a = []
678
 
        lines_b = []
679
 
        ch_a = ch_b = False
680
 
 
681
 
        for state, line in plan:
682
 
            if state == 'unchanged' or state == 'killed-both':
683
 
                # resync and flush queued conflicts changes if any
684
 
                if not lines_a and not lines_b:
685
 
                    pass
686
 
                elif ch_a and not ch_b:
687
 
                    # one-sided change:                    
688
 
                    for l in lines_a: yield l
689
 
                elif ch_b and not ch_a:
690
 
                    for l in lines_b: yield l
691
 
                elif lines_a == lines_b:
692
 
                    for l in lines_a: yield l
693
 
                else:
694
 
                    yield '<<<<\n'
695
 
                    for l in lines_a: yield l
696
 
                    yield '====\n'
697
 
                    for l in lines_b: yield l
698
 
                    yield '>>>>\n'
699
 
 
700
 
                del lines_a[:]
701
 
                del lines_b[:]
702
 
                ch_a = ch_b = False
703
 
                
704
 
            if state == 'unchanged':
705
 
                if line:
706
 
                    yield line
707
 
            elif state == 'killed-a':
708
 
                ch_a = True
709
 
                lines_b.append(line)
710
 
            elif state == 'killed-b':
711
 
                ch_b = True
712
 
                lines_a.append(line)
713
 
            elif state == 'new-a':
714
 
                ch_a = True
715
 
                lines_a.append(line)
716
 
            elif state == 'new-b':
717
 
                ch_b = True
718
 
                lines_b.append(line)
719
 
            else:
720
 
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
721
 
                                 'killed-both'), \
722
 
                       state
723
 
 
724
 
                
725
 
 
726
 
 
727
 
 
 
743
    def _join(self, other, pb, msg, version_ids, ignore_missing):
 
744
        """Worker routine for join()."""
 
745
        if not other.versions():
 
746
            return          # nothing to update, easy
 
747
 
 
748
        if not version_ids:
 
749
            # versions is never none, InterWeave checks this.
 
750
            return 0
 
751
 
 
752
        # two loops so that we do not change ourselves before verifying it
 
753
        # will be ok
 
754
        # work through in index order to make sure we get all dependencies
 
755
        names_to_join = []
 
756
        processed = 0
 
757
        # get the selected versions only that are in other.versions.
 
758
        version_ids = set(other.versions()).intersection(set(version_ids))
 
759
        # pull in the referenced graph.
 
760
        version_ids = other.get_ancestry(version_ids)
 
761
        pending_graph = [(version, other.get_parents(version)) for
 
762
                         version in version_ids]
 
763
        for name in topo_sort(pending_graph):
 
764
            other_idx = other._name_map[name]
 
765
            # returns True if we have it, False if we need it.
 
766
            if not self._check_version_consistent(other, other_idx, name):
 
767
                names_to_join.append((other_idx, name))
 
768
            processed += 1
 
769
 
 
770
 
 
771
        if pb and not msg:
 
772
            msg = 'weave join'
 
773
 
 
774
        merged = 0
 
775
        time0 = time.time()
 
776
        for other_idx, name in names_to_join:
 
777
            # TODO: If all the parents of the other version are already
 
778
            # present then we can avoid some work by just taking the delta
 
779
            # and adjusting the offsets.
 
780
            new_parents = self._imported_parents(other, other_idx)
 
781
            sha1 = other._sha1s[other_idx]
 
782
 
 
783
            merged += 1
 
784
 
 
785
            if pb:
 
786
                pb.update(msg, merged, len(names_to_join))
 
787
           
 
788
            lines = other.get_lines(other_idx)
 
789
            self._add(name, lines, new_parents, sha1)
 
790
 
 
791
        mutter("merged = %d, processed = %d, file_id=%s; deltat=%d"%(
 
792
                merged, processed, self._weave_name, time.time()-time0))
 
793
 
 
794
    def _imported_parents(self, other, other_idx):
 
795
        """Return list of parents in self corresponding to indexes in other."""
 
796
        new_parents = []
 
797
        for parent_idx in other._parents[other_idx]:
 
798
            parent_name = other._names[parent_idx]
 
799
            if parent_name not in self._name_map:
 
800
                # should not be possible
 
801
                raise WeaveError("missing parent {%s} of {%s} in %r" 
 
802
                                 % (parent_name, other._name_map[other_idx], self))
 
803
            new_parents.append(self._name_map[parent_name])
 
804
        return new_parents
 
805
 
 
806
    def _check_version_consistent(self, other, other_idx, name):
 
807
        """Check if a version in consistent in this and other.
 
808
 
 
809
        To be consistent it must have:
 
810
 
 
811
         * the same text
 
812
         * the same direct parents (by name, not index, and disregarding
 
813
           order)
 
814
        
 
815
        If present & correct return True;
 
816
        if not present in self return False; 
 
817
        if inconsistent raise error."""
 
818
        this_idx = self._name_map.get(name, -1)
 
819
        if this_idx != -1:
 
820
            if self._sha1s[this_idx] != other._sha1s[other_idx]:
 
821
                raise errors.WeaveTextDiffers(name, self, other)
 
822
            self_parents = self._parents[this_idx]
 
823
            other_parents = other._parents[other_idx]
 
824
            n1 = set([self._names[i] for i in self_parents])
 
825
            n2 = set([other._names[i] for i in other_parents])
 
826
            if not self._compatible_parents(n1, n2):
 
827
                raise WeaveParentMismatch("inconsistent parents "
 
828
                    "for version {%s}: %s vs %s" % (name, n1, n2))
 
829
            else:
 
830
                return True         # ok!
 
831
        else:
 
832
            return False
 
833
 
 
834
    def _reweave(self, other, pb, msg):
 
835
        """Reweave self with other - internal helper for join().
 
836
 
 
837
        :param other: The other weave to merge
 
838
        :param pb: An optional progress bar, indicating how far done we are
 
839
        :param msg: An optional message for the progress
 
840
        """
 
841
        new_weave = _reweave(self, other, pb=pb, msg=msg)
 
842
        self._copy_weave_content(new_weave)
 
843
 
 
844
    def _copy_weave_content(self, otherweave):
 
845
        """adsorb the content from otherweave."""
 
846
        for attr in self.__slots__:
 
847
            if attr != '_weave_name':
 
848
                setattr(self, attr, copy(getattr(otherweave, attr)))
 
849
 
 
850
 
 
851
class WeaveFile(Weave):
 
852
    """A WeaveFile represents a Weave on disk and writes on change."""
 
853
 
 
854
    WEAVE_SUFFIX = '.weave'
 
855
    
 
856
    def __init__(self, name, transport, filemode=None, create=False, access_mode='w'):
 
857
        """Create a WeaveFile.
 
858
        
 
859
        :param create: If not True, only open an existing knit.
 
860
        """
 
861
        super(WeaveFile, self).__init__(name, access_mode)
 
862
        self._transport = transport
 
863
        self._filemode = filemode
 
864
        try:
 
865
            _read_weave_v5(self._transport.get(name + WeaveFile.WEAVE_SUFFIX), self)
 
866
        except errors.NoSuchFile:
 
867
            if not create:
 
868
                raise
 
869
            # new file, save it
 
870
            self._save()
 
871
 
 
872
    def _add_lines(self, version_id, parents, lines, parent_texts,
 
873
        left_matching_blocks, nostore_sha, random_id, check_content):
 
874
        """Add a version and save the weave."""
 
875
        self.check_not_reserved_id(version_id)
 
876
        result = super(WeaveFile, self)._add_lines(version_id, parents, lines,
 
877
            parent_texts, left_matching_blocks, nostore_sha, random_id,
 
878
            check_content)
 
879
        self._save()
 
880
        return result
 
881
 
 
882
    def _clone_text(self, new_version_id, old_version_id, parents):
 
883
        """See VersionedFile.clone_text."""
 
884
        super(WeaveFile, self)._clone_text(new_version_id, old_version_id, parents)
 
885
        self._save
 
886
 
 
887
    def copy_to(self, name, transport):
 
888
        """See VersionedFile.copy_to()."""
 
889
        # as we are all in memory always, just serialise to the new place.
 
890
        sio = StringIO()
 
891
        write_weave_v5(self, sio)
 
892
        sio.seek(0)
 
893
        transport.put_file(name + WeaveFile.WEAVE_SUFFIX, sio, self._filemode)
 
894
 
 
895
    def create_empty(self, name, transport, filemode=None):
 
896
        return WeaveFile(name, transport, filemode, create=True)
 
897
 
 
898
    def _save(self):
 
899
        """Save the weave."""
 
900
        self._check_write_ok()
 
901
        sio = StringIO()
 
902
        write_weave_v5(self, sio)
 
903
        sio.seek(0)
 
904
        self._transport.put_file(self._weave_name + WeaveFile.WEAVE_SUFFIX,
 
905
                                 sio,
 
906
                                 self._filemode)
 
907
 
 
908
    @staticmethod
 
909
    def get_suffixes():
 
910
        """See VersionedFile.get_suffixes()."""
 
911
        return [WeaveFile.WEAVE_SUFFIX]
 
912
 
 
913
    def join(self, other, pb=None, msg=None, version_ids=None,
 
914
             ignore_missing=False):
 
915
        """Join other into self and save."""
 
916
        super(WeaveFile, self).join(other, pb, msg, version_ids, ignore_missing)
 
917
        self._save()
 
918
 
 
919
 
 
920
def _reweave(wa, wb, pb=None, msg=None):
 
921
    """Combine two weaves and return the result.
 
922
 
 
923
    This works even if a revision R has different parents in 
 
924
    wa and wb.  In the resulting weave all the parents are given.
 
925
 
 
926
    This is done by just building up a new weave, maintaining ordering 
 
927
    of the versions in the two inputs.  More efficient approaches
 
928
    might be possible but it should only be necessary to do 
 
929
    this operation rarely, when a new previously ghost version is 
 
930
    inserted.
 
931
 
 
932
    :param pb: An optional progress bar, indicating how far done we are
 
933
    :param msg: An optional message for the progress
 
934
    """
 
935
    wr = Weave()
 
936
    ia = ib = 0
 
937
    queue_a = range(wa.num_versions())
 
938
    queue_b = range(wb.num_versions())
 
939
    # first determine combined parents of all versions
 
940
    # map from version name -> all parent names
 
941
    combined_parents = _reweave_parent_graphs(wa, wb)
 
942
    mutter("combined parents: %r", combined_parents)
 
943
    order = topo_sort(combined_parents.iteritems())
 
944
    mutter("order to reweave: %r", order)
 
945
 
 
946
    if pb and not msg:
 
947
        msg = 'reweave'
 
948
 
 
949
    for idx, name in enumerate(order):
 
950
        if pb:
 
951
            pb.update(msg, idx, len(order))
 
952
        if name in wa._name_map:
 
953
            lines = wa.get_lines(name)
 
954
            if name in wb._name_map:
 
955
                lines_b = wb.get_lines(name)
 
956
                if lines != lines_b:
 
957
                    mutter('Weaves differ on content. rev_id {%s}', name)
 
958
                    mutter('weaves: %s, %s', wa._weave_name, wb._weave_name)
 
959
                    import difflib
 
960
                    lines = list(difflib.unified_diff(lines, lines_b,
 
961
                            wa._weave_name, wb._weave_name))
 
962
                    mutter('lines:\n%s', ''.join(lines))
 
963
                    raise errors.WeaveTextDiffers(name, wa, wb)
 
964
        else:
 
965
            lines = wb.get_lines(name)
 
966
        wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
 
967
    return wr
 
968
 
 
969
def _reweave_parent_graphs(wa, wb):
 
970
    """Return combined parent ancestry for two weaves.
 
971
    
 
972
    Returned as a list of (version_name, set(parent_names))"""
 
973
    combined = {}
 
974
    for weave in [wa, wb]:
 
975
        for idx, name in enumerate(weave._names):
 
976
            p = combined.setdefault(name, set())
 
977
            p.update(map(weave._idx_to_name, weave._parents[idx]))
 
978
    return combined
728
979
 
729
980
 
730
981
def weave_toc(w):
733
984
    for i in (6, 50, 10, 10):
734
985
        print '-' * i,
735
986
    print
736
 
    for i in range(w.numversions()):
 
987
    for i in range(w.num_versions()):
737
988
        sha1 = w._sha1s[i]
738
989
        name = w._names[i]
739
990
        parent_str = ' '.join(map(str, w._parents[i]))
741
992
 
742
993
 
743
994
 
744
 
def weave_stats(weave_file):
745
 
    from bzrlib.progress import ProgressBar
 
995
def weave_stats(weave_file, pb):
746
996
    from bzrlib.weavefile import read_weave
747
997
 
748
 
    pb = ProgressBar()
749
 
 
750
998
    wf = file(weave_file, 'rb')
751
999
    w = read_weave(wf)
752
1000
    # FIXME: doesn't work on pipes
756
1004
    vers = len(w)
757
1005
    for i in range(vers):
758
1006
        pb.update('checking sizes', i, vers)
759
 
        for line in w.get_iter(i):
 
1007
        for origin, lineno, line in w._extract([i]):
760
1008
            total += len(line)
761
1009
 
762
1010
    pb.clear()
789
1037
        Add NEWTEXT, with specified parent versions.
790
1038
    weave annotate WEAVEFILE VERSION
791
1039
        Display origin of each line.
792
 
    weave mash WEAVEFILE VERSION...
793
 
        Display composite of all selected versions.
794
1040
    weave merge WEAVEFILE VERSION1 VERSION2 > OUT
795
1041
        Auto-merge two versions and display conflicts.
 
1042
    weave diff WEAVEFILE VERSION1 VERSION2 
 
1043
        Show differences between two versions.
796
1044
 
797
1045
example:
798
1046
 
823
1071
def main(argv):
824
1072
    import sys
825
1073
    import os
826
 
    from weavefile import write_weave, read_weave
 
1074
    try:
 
1075
        import bzrlib
 
1076
    except ImportError:
 
1077
        # in case we're run directly from the subdirectory
 
1078
        sys.path.append('..')
 
1079
        import bzrlib
 
1080
    from bzrlib.weavefile import write_weave, read_weave
827
1081
    from bzrlib.progress import ProgressBar
828
1082
 
829
1083
    try:
862
1116
        w = readit()
863
1117
        sys.stdout.writelines(w.get_iter(int(argv[3])))
864
1118
        
865
 
    elif cmd == 'mash': # get composite
 
1119
    elif cmd == 'diff':
866
1120
        w = readit()
867
 
        sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
868
 
 
 
1121
        fn = argv[2]
 
1122
        v1, v2 = map(int, argv[3:5])
 
1123
        lines1 = w.get(v1)
 
1124
        lines2 = w.get(v2)
 
1125
        diff_gen = bzrlib.patiencediff.unified_diff(lines1, lines2,
 
1126
                                '%s version %d' % (fn, v1),
 
1127
                                '%s version %d' % (fn, v2))
 
1128
        sys.stdout.writelines(diff_gen)
 
1129
            
869
1130
    elif cmd == 'annotate':
870
1131
        w = readit()
871
1132
        # newline is added to all lines regardless; too hard to get
883
1144
        weave_toc(readit())
884
1145
 
885
1146
    elif cmd == 'stats':
886
 
        weave_stats(argv[2])
 
1147
        weave_stats(argv[2], ProgressBar())
887
1148
        
888
1149
    elif cmd == 'check':
889
1150
        w = readit()
890
1151
        pb = ProgressBar()
891
1152
        w.check(pb)
892
1153
        pb.clear()
893
 
        print '%d versions ok' % w.numversions()
 
1154
        print '%d versions ok' % w.num_versions()
894
1155
 
895
1156
    elif cmd == 'inclusions':
896
1157
        w = readit()
901
1162
        print ' '.join(map(str, w._parents[int(argv[3])]))
902
1163
 
903
1164
    elif cmd == 'plan-merge':
 
1165
        # replaced by 'bzr weave-plan-merge'
904
1166
        w = readit()
905
1167
        for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
906
1168
            if line:
907
1169
                print '%14s | %s' % (state, line),
908
 
 
909
1170
    elif cmd == 'merge':
 
1171
        # replaced by 'bzr weave-merge-text'
910
1172
        w = readit()
911
1173
        p = w.plan_merge(int(argv[3]), int(argv[4]))
912
1174
        sys.stdout.writelines(w.weave_merge(p))
913
 
            
914
 
    elif cmd == 'mash-merge':
915
 
        if len(argv) != 5:
916
 
            usage()
917
 
            return 1
918
 
 
919
 
        w = readit()
920
 
        v1, v2 = map(int, argv[3:5])
921
 
 
922
 
        basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
923
 
 
924
 
        base_lines = list(w.mash_iter(basis))
925
 
        a_lines = list(w.get(v1))
926
 
        b_lines = list(w.get(v2))
927
 
 
928
 
        from bzrlib.merge3 import Merge3
929
 
        m3 = Merge3(base_lines, a_lines, b_lines)
930
 
 
931
 
        name_a = 'version %d' % v1
932
 
        name_b = 'version %d' % v2
933
 
        sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
934
1175
    else:
935
1176
        raise ValueError('unknown command %r' % cmd)
936
1177
    
937
1178
 
938
 
 
939
 
def profile_main(argv): 
940
 
    import tempfile, hotshot, hotshot.stats
941
 
 
942
 
    prof_f = tempfile.NamedTemporaryFile()
943
 
 
944
 
    prof = hotshot.Profile(prof_f.name)
945
 
 
946
 
    ret = prof.runcall(main, argv)
947
 
    prof.close()
948
 
 
949
 
    stats = hotshot.stats.load(prof_f.name)
950
 
    #stats.strip_dirs()
951
 
    stats.sort_stats('cumulative')
952
 
    ## XXX: Might like to write to stderr or the trace file instead but
953
 
    ## print_stats seems hardcoded to stdout
954
 
    stats.print_stats(20)
955
 
            
956
 
    return ret
957
 
 
958
 
 
959
1179
if __name__ == '__main__':
960
1180
    import sys
961
 
    if '--profile' in sys.argv:
962
 
        args = sys.argv[:]
963
 
        args.remove('--profile')
964
 
        sys.exit(profile_main(args))
965
 
    else:
966
 
        sys.exit(main(sys.argv))
967
 
 
 
1181
    sys.exit(main(sys.argv))
 
1182
 
 
1183
 
 
1184
class InterWeave(InterVersionedFile):
 
1185
    """Optimised code paths for weave to weave operations."""
 
1186
    
 
1187
    _matching_file_from_factory = staticmethod(WeaveFile)
 
1188
    _matching_file_to_factory = staticmethod(WeaveFile)
 
1189
    
 
1190
    @staticmethod
 
1191
    def is_compatible(source, target):
 
1192
        """Be compatible with weaves."""
 
1193
        try:
 
1194
            return (isinstance(source, Weave) and
 
1195
                    isinstance(target, Weave))
 
1196
        except AttributeError:
 
1197
            return False
 
1198
 
 
1199
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
 
1200
        """See InterVersionedFile.join."""
 
1201
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
 
1202
        if self.target.versions() == [] and version_ids is None:
 
1203
            self.target._copy_weave_content(self.source)
 
1204
            return
 
1205
        try:
 
1206
            self.target._join(self.source, pb, msg, version_ids, ignore_missing)
 
1207
        except errors.WeaveParentMismatch:
 
1208
            self.target._reweave(self.source, pb, msg)
 
1209
 
 
1210
 
 
1211
InterVersionedFile.register_optimiser(InterWeave)