~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
27
27
# property.
28
28
 
29
29
# 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
 
30
# rather than being split up in some other way.  We could accomodate
31
31
# binaries, perhaps by naively splitting on \n or perhaps using
32
32
# something like a rolling checksum.
33
33
 
66
66
# be done fairly efficiently because the sequence numbers constrain
67
67
# the possible relationships.
68
68
 
69
 
# FIXME: the conflict markers should be *7* characters
70
69
 
71
 
from copy import copy
72
 
from cStringIO import StringIO
73
 
import os
74
70
import sha
75
 
import time
76
 
import warnings
 
71
from difflib import SequenceMatcher
77
72
 
78
 
from bzrlib import (
79
 
    progress,
80
 
    )
81
73
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.symbol_versioning import (deprecated_method,
92
 
        deprecated_function,
93
 
        zero_eight,
94
 
        )
 
74
from bzrlib.errors import WeaveError, WeaveFormatError, WeaveParentMismatch, \
 
75
        WeaveRevisionNotPresent, WeaveRevisionAlreadyPresent
95
76
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):
 
77
 
 
78
 
 
79
class Weave(object):
101
80
    """weave - versioned text file storage.
102
81
    
103
82
    A Weave manages versions of line-based text files, keeping track
187
166
    """
188
167
 
189
168
    __slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
190
 
                 '_weave_name', '_matcher']
 
169
                 '_weave_name']
191
170
    
192
 
    def __init__(self, weave_name=None, access_mode='w', matcher=None):
193
 
        super(Weave, self).__init__(access_mode)
 
171
    def __init__(self, weave_name=None):
194
172
        self._weave = []
195
173
        self._parents = []
196
174
        self._sha1s = []
197
175
        self._names = []
198
176
        self._name_map = {}
199
177
        self._weave_name = weave_name
200
 
        if matcher is None:
201
 
            self._matcher = bzrlib.patiencediff.PatienceSequenceMatcher
202
 
        else:
203
 
            self._matcher = matcher
204
178
 
205
179
    def __repr__(self):
206
180
        return "Weave(%r)" % self._weave_name
207
181
 
 
182
 
208
183
    def copy(self):
209
184
        """Return a deep copy of self.
210
185
        
224
199
        return self._parents == other._parents \
225
200
               and self._weave == other._weave \
226
201
               and self._sha1s == other._sha1s 
 
202
 
227
203
    
228
204
    def __ne__(self, other):
229
205
        return not self.__eq__(other)
230
206
 
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)
 
207
    def __contains__(self, name):
 
208
        return self._name_map.has_key(name)
 
209
 
 
210
    def maybe_lookup(self, name_or_index):
 
211
        """Convert possible symbolic name to index, or pass through indexes."""
 
212
        if isinstance(name_or_index, (int, long)):
 
213
            return name_or_index
 
214
        else:
 
215
            return self.lookup(name_or_index)
 
216
 
 
217
        
240
218
    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
219
        """Convert symbolic version name to index."""
250
 
        self.check_not_reserved_id(name)
251
220
        try:
252
221
            return self._name_map[name]
253
222
        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)
 
223
            raise WeaveRevisionNotPresent(name, self)
 
224
 
262
225
    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
226
        return self._names[:]
269
227
 
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)])
 
228
    def iter_names(self):
 
229
        """Yield a list of all names in this weave."""
 
230
        return iter(self._names)
 
231
 
 
232
    def idx_to_name(self, version):
 
233
        return self._names[version]
435
234
 
436
235
    def _check_repeated_add(self, name, parents, text, sha1):
437
236
        """Check that a duplicated add is OK.
438
237
 
439
238
        If it is, return the (old) index; otherwise raise an exception.
440
239
        """
441
 
        idx = self._lookup(name)
 
240
        idx = self.lookup(name)
442
241
        if sorted(self._parents[idx]) != sorted(parents) \
443
242
            or sha1 != self._sha1s[idx]:
444
 
            raise RevisionAlreadyPresent(name, self._weave_name)
 
243
            raise WeaveRevisionAlreadyPresent(name, self)
445
244
        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)
 
245
        
457
246
    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
247
        """Add a single text on top of the weave.
463
248
  
464
249
        Returns the index number of the newly added version.
465
250
 
466
 
        version_id
 
251
        name
467
252
            Symbolic name for this version.
468
253
            (Typically the revision-id of the revision that added it.)
469
254
 
470
255
        parents
471
256
            List or set of direct parent version numbers.
472
257
            
473
 
        lines
 
258
        text
474
259
            Sequence of lines to be added in the new version.
 
260
 
 
261
        sha -- SHA-1 of the file, if known.  This is trusted to be
 
262
            correct if supplied.
475
263
        """
476
 
 
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)
484
 
 
 
264
        from bzrlib.osutils import sha_strings
 
265
 
 
266
        assert isinstance(name, basestring)
 
267
        if sha1 is None:
 
268
            sha1 = sha_strings(text)
 
269
        if name in self._name_map:
 
270
            return self._check_repeated_add(name, parents, text, sha1)
 
271
 
 
272
        parents = map(self.maybe_lookup, parents)
485
273
        self._check_versions(parents)
486
 
        ## self._check_lines(lines)
 
274
        ## self._check_lines(text)
487
275
        new_version = len(self._parents)
488
276
 
 
277
 
489
278
        # if we abort after here the (in-memory) weave will be corrupt because only
490
279
        # some fields are updated
491
 
        # XXX: FIXME implement a succeed-or-fail of the rest of this routine.
492
 
        #      - Robert Collins 20060226
493
280
        self._parents.append(parents[:])
494
281
        self._sha1s.append(sha1)
495
 
        self._names.append(version_id)
496
 
        self._name_map[version_id] = new_version
 
282
        self._names.append(name)
 
283
        self._name_map[name] = new_version
497
284
 
498
285
            
499
286
        if not parents:
501
288
            # this more quickly by just appending unconditionally.
502
289
            # even more specially, if we're adding an empty text we
503
290
            # need do nothing at all.
504
 
            if lines:
 
291
            if text:
505
292
                self._weave.append(('{', new_version))
506
 
                self._weave.extend(lines)
 
293
                self._weave.extend(text)
507
294
                self._weave.append(('}', None))
 
295
        
508
296
            return new_version
509
297
 
510
298
        if len(parents) == 1:
514
302
                return new_version
515
303
            
516
304
 
517
 
        ancestors = self._inclusions(parents)
 
305
        ancestors = self.inclusions(parents)
518
306
 
519
307
        l = self._weave
520
308
 
527
315
 
528
316
        # another small special case: a merge, producing the same text
529
317
        # as auto-merge
530
 
        if lines == basis_lines:
 
318
        if text == basis_lines:
531
319
            return new_version            
532
320
 
533
 
        # add a sentinel, because we can also match against the final line
 
321
        # add a sentinal, because we can also match against the final line
534
322
        basis_lineno.append(len(self._weave))
535
323
 
536
324
        # XXX: which line of the weave should we really consider
540
328
        #print 'basis_lines:', basis_lines
541
329
        #print 'new_lines:  ', lines
542
330
 
543
 
        s = self._matcher(None, basis_lines, lines)
 
331
        s = SequenceMatcher(None, basis_lines, text)
544
332
 
545
333
        # offset gives the number of lines that have been inserted
546
334
        # into the weave up to the current point; if the original edit instruction
557
345
            i1 = basis_lineno[i1]
558
346
            i2 = basis_lineno[i2]
559
347
 
560
 
            assert 0 <= j1 <= j2 <= len(lines)
 
348
            assert 0 <= j1 <= j2 <= len(text)
561
349
 
562
350
            #print tag, i1, i2, j1, j2
563
351
 
574
362
                # we don't destroy ourselves
575
363
                i = i2 + offset
576
364
                self._weave[i:i] = ([('{', new_version)] 
577
 
                                    + lines[j1:j2] 
 
365
                                    + text[j1:j2] 
578
366
                                    + [('}', None)])
579
367
                offset += 2 + (j2 - j1)
 
368
 
580
369
        return new_version
581
370
 
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)
 
371
    def add_identical(self, old_rev_id, new_rev_id, parents):
 
372
        """Add an identical text to old_rev_id as new_rev_id."""
 
373
        old_lines = self.get(self.lookup(old_rev_id))
 
374
        self.add(new_rev_id, parents, old_lines)
586
375
 
587
 
    def _inclusions(self, versions):
 
376
    def inclusions(self, versions):
588
377
        """Return set of all ancestors of given version(s)."""
589
 
        if not len(versions):
590
 
            return []
591
378
        i = set(versions)
592
379
        for v in xrange(max(versions), 0, -1):
593
380
            if v in i:
597
384
        ## except IndexError:
598
385
        ##     raise ValueError("version %d not present in weave" % v)
599
386
 
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:
 
387
 
 
388
    def parents(self, version):
 
389
        return self._parents[version]
 
390
 
 
391
 
 
392
    def parent_names(self, version):
 
393
        """Return version names for parents of a version."""
 
394
        return map(self.idx_to_name, self._parents[self.lookup(version)])
 
395
 
 
396
 
 
397
    def minimal_parents(self, version):
 
398
        """Find the minimal set of parents for the version."""
 
399
        included = self._parents[version]
 
400
        if not included:
604
401
            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):
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]
 
402
        
 
403
        li = list(included)
 
404
        li.sort(reverse=True)
 
405
 
 
406
        mininc = []
 
407
        gotit = set()
 
408
 
 
409
        for pv in li:
 
410
            if pv not in gotit:
 
411
                mininc.append(pv)
 
412
                gotit.update(self.inclusions(pv))
 
413
 
 
414
        assert mininc[0] >= 0
 
415
        assert mininc[-1] < version
 
416
        return mininc
 
417
 
 
418
 
616
419
 
617
420
    def _check_lines(self, text):
618
421
        if not isinstance(text, list):
633
436
            except IndexError:
634
437
                raise IndexError("invalid version number %r" % i)
635
438
 
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.
 
439
    
 
440
    def annotate(self, name_or_index):
 
441
        return list(self.annotate_iter(name_or_index))
 
442
 
 
443
 
 
444
    def annotate_iter(self, name_or_index):
 
445
        """Yield list of (index-id, line) pairs for the specified version.
646
446
 
647
447
        The index indicates when the line originated in the weave."""
648
 
        incls = [self._lookup(version_id)]
 
448
        incls = [self.maybe_lookup(name_or_index)]
649
449
        for origin, lineno, text in self._extract(incls):
650
 
            yield self._idx_to_name(origin), text
 
450
            yield origin, text
651
451
 
652
 
    @deprecated_method(zero_eight)
653
452
    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."""
 
453
        """Walk the weave.
 
454
 
 
455
        Yields sequence of
 
456
        (lineno, insert, deletes, text)
 
457
        for each literal line.
 
458
        """
680
459
        
681
460
        istack = []
682
461
        dset = set()
684
463
        lineno = 0         # line of weave, 0-based
685
464
 
686
465
        for l in self._weave:
687
 
            if l.__class__ == tuple:
 
466
            if isinstance(l, tuple):
688
467
                c, v = l
689
468
                isactive = None
690
469
                if c == '{':
691
 
                    istack.append(self._names[v])
 
470
                    istack.append(v)
692
471
                elif c == '}':
693
472
                    istack.pop()
694
473
                elif c == '[':
695
 
                    assert self._names[v] not in dset
696
 
                    dset.add(self._names[v])
 
474
                    assert v not in dset
 
475
                    dset.add(v)
697
476
                elif c == ']':
698
 
                    dset.remove(self._names[v])
 
477
                    dset.remove(v)
699
478
                else:
700
479
                    raise WeaveFormatError('unexpected instruction %r' % v)
701
480
            else:
702
 
                assert l.__class__ in (str, unicode)
 
481
                assert isinstance(l, basestring)
703
482
                assert istack
704
 
                yield lineno, istack[-1], frozenset(dset), l
 
483
                yield lineno, istack[-1], dset, l
705
484
            lineno += 1
706
485
 
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
 
486
 
760
487
 
761
488
    def _extract(self, versions):
762
489
        """Yield annotation of lines in included set.
771
498
            if not isinstance(i, int):
772
499
                raise ValueError(i)
773
500
            
774
 
        included = self._inclusions(versions)
 
501
        included = self.inclusions(versions)
775
502
 
776
503
        istack = []
777
 
        iset = set()
778
504
        dset = set()
779
505
 
780
506
        lineno = 0         # line of weave, 0-based
785
511
 
786
512
        WFE = WeaveFormatError
787
513
 
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
514
        for l in self._weave:
816
 
            if l.__class__ == tuple:
 
515
            if isinstance(l, tuple):
817
516
                c, v = l
818
517
                isactive = None
819
518
                if c == '{':
820
 
                    assert v not in iset
 
519
                    assert v not in istack
821
520
                    istack.append(v)
822
 
                    iset.add(v)
823
521
                elif c == '}':
824
 
                    iset.remove(istack.pop())
 
522
                    istack.pop()
825
523
                elif c == '[':
826
524
                    if v in included:
827
525
                        assert v not in dset
832
530
                        assert v in dset
833
531
                        dset.remove(v)
834
532
            else:
835
 
                assert l.__class__ in (str, unicode)
 
533
                assert isinstance(l, basestring)
836
534
                if isactive is None:
837
535
                    isactive = (not dset) and istack and (istack[-1] in included)
838
536
                if isactive:
846
544
                                   % dset)
847
545
        return result
848
546
 
849
 
    @deprecated_method(zero_eight)
 
547
 
850
548
    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)
 
549
        """Yield lines for the specified version."""
 
550
        incls = [self.maybe_lookup(name_or_index)]
 
551
        for origin, lineno, line in self._extract(incls):
 
552
            yield line
 
553
 
 
554
 
 
555
    def get_text(self, name_or_index):
 
556
        return ''.join(self.get_iter(name_or_index))
 
557
        assert isinstance(version, int)
 
558
 
 
559
 
 
560
    def get_lines(self, name_or_index):
 
561
        return list(self.get_iter(name_or_index))
 
562
 
 
563
 
 
564
    get = get_lines
 
565
 
 
566
 
 
567
    def mash_iter(self, included):
 
568
        """Return composed version of multiple included versions."""
 
569
        included = map(self.maybe_lookup, included)
 
570
        for origin, lineno, text in self._extract(included):
 
571
            yield text
 
572
 
 
573
 
 
574
    def dump(self, to_file):
 
575
        from pprint import pprint
 
576
        print >>to_file, "Weave._weave = ",
 
577
        pprint(self._weave, to_file)
 
578
        print >>to_file, "Weave._parents = ",
 
579
        pprint(self._parents, to_file)
 
580
 
 
581
 
 
582
 
895
583
    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
584
        l = len(self._parents)
905
585
        assert l == len(self._sha1s)
906
586
        return l
907
587
 
908
 
    __len__ = num_versions
 
588
 
 
589
    def __len__(self):
 
590
        return self.numversions()
 
591
 
909
592
 
910
593
    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()):
 
594
        # check no circular inclusions
 
595
        for version in range(self.numversions()):
915
596
            inclusions = list(self._parents[version])
916
597
            if inclusions:
917
598
                inclusions.sort()
919
600
                    raise WeaveFormatError("invalid included version %d for index %d"
920
601
                                           % (inclusions[-1], version))
921
602
 
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():
 
603
        # try extracting all versions; this is a bit slow and parallel
 
604
        # extraction could be used
 
605
        nv = self.numversions()
 
606
        for version in range(nv):
950
607
            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]
 
608
                progress_bar.update('checking text', version, nv)
 
609
            s = sha.new()
 
610
            for l in self.get_iter(version):
 
611
                s.update(l)
 
612
            hd = s.hexdigest()
 
613
            expected = self._sha1s[version]
964
614
            if hd != expected:
965
 
                raise errors.WeaveInvalidChecksum(
966
 
                        "mismatched sha1 for version %s: "
967
 
                        "got %s, expected %s"
968
 
                        % (version, hd, expected))
 
615
                raise WeaveError("mismatched sha1 for version %d; "
 
616
                                 "got %s, expected %s"
 
617
                                 % (version, hd, expected))
969
618
 
970
619
        # TODO: check insertions are properly nested, that there are
971
620
        # no lines outside of insertion blocks, that deletions are
972
621
        # properly paired, etc.
973
622
 
974
 
    def _join(self, other, pb, msg, version_ids, ignore_missing):
975
 
        """Worker routine for join()."""
976
 
        if not other.versions():
 
623
 
 
624
    def _delta(self, included, lines):
 
625
        """Return changes from basis to new revision.
 
626
 
 
627
        The old text for comparison is the union of included revisions.
 
628
 
 
629
        This is used in inserting a new text.
 
630
 
 
631
        Delta is returned as a sequence of
 
632
        (weave1, weave2, newlines).
 
633
 
 
634
        This indicates that weave1:weave2 of the old weave should be
 
635
        replaced by the sequence of lines in newlines.  Note that
 
636
        these line numbers are positions in the total weave and don't
 
637
        correspond to the lines in any extracted version, or even the
 
638
        extracted union of included versions.
 
639
 
 
640
        If line1=line2, this is a pure insert; if newlines=[] this is a
 
641
        pure delete.  (Similar to difflib.)
 
642
        """
 
643
        raise NotImplementedError()
 
644
 
 
645
            
 
646
    def plan_merge(self, ver_a, ver_b):
 
647
        """Return pseudo-annotation indicating how the two versions merge.
 
648
 
 
649
        This is computed between versions a and b and their common
 
650
        base.
 
651
 
 
652
        Weave lines present in none of them are skipped entirely.
 
653
        """
 
654
        inc_a = self.inclusions([ver_a])
 
655
        inc_b = self.inclusions([ver_b])
 
656
        inc_c = inc_a & inc_b
 
657
 
 
658
        for lineno, insert, deleteset, line in self._walk():
 
659
            if deleteset & inc_c:
 
660
                # killed in parent; can't be in either a or b
 
661
                # not relevant to our work
 
662
                yield 'killed-base', line
 
663
            elif insert in inc_c:
 
664
                # was inserted in base
 
665
                killed_a = bool(deleteset & inc_a)
 
666
                killed_b = bool(deleteset & inc_b)
 
667
                if killed_a and killed_b:
 
668
                    yield 'killed-both', line
 
669
                elif killed_a:
 
670
                    yield 'killed-a', line
 
671
                elif killed_b:
 
672
                    yield 'killed-b', line
 
673
                else:
 
674
                    yield 'unchanged', line
 
675
            elif insert in inc_a:
 
676
                if deleteset & inc_a:
 
677
                    yield 'ghost-a', line
 
678
                else:
 
679
                    # new in A; not in B
 
680
                    yield 'new-a', line
 
681
            elif insert in inc_b:
 
682
                if deleteset & inc_b:
 
683
                    yield 'ghost-b', line
 
684
                else:
 
685
                    yield 'new-b', line
 
686
            else:
 
687
                # not in either revision
 
688
                yield 'irrelevant', line
 
689
 
 
690
        yield 'unchanged', ''           # terminator
 
691
 
 
692
 
 
693
 
 
694
    def weave_merge(self, plan):
 
695
        lines_a = []
 
696
        lines_b = []
 
697
        ch_a = ch_b = False
 
698
 
 
699
        for state, line in plan:
 
700
            if state == 'unchanged' or state == 'killed-both':
 
701
                # resync and flush queued conflicts changes if any
 
702
                if not lines_a and not lines_b:
 
703
                    pass
 
704
                elif ch_a and not ch_b:
 
705
                    # one-sided change:                    
 
706
                    for l in lines_a: yield l
 
707
                elif ch_b and not ch_a:
 
708
                    for l in lines_b: yield l
 
709
                elif lines_a == lines_b:
 
710
                    for l in lines_a: yield l
 
711
                else:
 
712
                    yield '<<<<<<<\n'
 
713
                    for l in lines_a: yield l
 
714
                    yield '=======\n'
 
715
                    for l in lines_b: yield l
 
716
                    yield '>>>>>>>\n'
 
717
 
 
718
                del lines_a[:]
 
719
                del lines_b[:]
 
720
                ch_a = ch_b = False
 
721
                
 
722
            if state == 'unchanged':
 
723
                if line:
 
724
                    yield line
 
725
            elif state == 'killed-a':
 
726
                ch_a = True
 
727
                lines_b.append(line)
 
728
            elif state == 'killed-b':
 
729
                ch_b = True
 
730
                lines_a.append(line)
 
731
            elif state == 'new-a':
 
732
                ch_a = True
 
733
                lines_a.append(line)
 
734
            elif state == 'new-b':
 
735
                ch_b = True
 
736
                lines_b.append(line)
 
737
            else:
 
738
                assert state in ('irrelevant', 'ghost-a', 'ghost-b', 'killed-base',
 
739
                                 'killed-both'), \
 
740
                       state
 
741
 
 
742
                
 
743
    def join(self, other):
 
744
        """Integrate versions from other into this weave.
 
745
 
 
746
        The resulting weave contains all the history of both weaves; 
 
747
        any version you could retrieve from either self or other can be 
 
748
        retrieved from self after this call.
 
749
 
 
750
        It is illegal for the two weaves to contain different values 
 
751
        or different parents for any version.  See also reweave().
 
752
        """
 
753
        if other.numversions() == 0:
977
754
            return          # nothing to update, easy
978
 
 
979
 
        if not version_ids:
980
 
            # versions is never none, InterWeave checks this.
981
 
            return 0
982
 
 
983
755
        # two loops so that we do not change ourselves before verifying it
984
756
        # will be ok
985
757
        # 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
 
758
        for other_idx, name in enumerate(other._names):
 
759
            if self._check_version_consistent(other, other_idx, name):
 
760
                continue
 
761
        for other_idx, name in enumerate(other._names):
 
762
            # TODO: If all the parents of the other version are already 
1009
763
            # present then we can avoid some work by just taking the delta
1010
764
            # and adjusting the offsets.
1011
765
            new_parents = self._imported_parents(other, other_idx)
 
766
            lines = other.get_lines(other_idx)
1012
767
            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
 
 
 
768
            self.add(name, new_parents, lines, sha1)
 
769
 
 
770
 
1025
771
    def _imported_parents(self, other, other_idx):
1026
772
        """Return list of parents in self corresponding to indexes in other."""
1027
773
        new_parents = []
1028
774
        for parent_idx in other._parents[other_idx]:
1029
775
            parent_name = other._names[parent_idx]
1030
 
            if parent_name not in self._name_map:
 
776
            if parent_name not in self._names:
1031
777
                # should not be possible
1032
778
                raise WeaveError("missing parent {%s} of {%s} in %r" 
1033
779
                                 % (parent_name, other._name_map[other_idx], self))
1049
795
        this_idx = self._name_map.get(name, -1)
1050
796
        if this_idx != -1:
1051
797
            if self._sha1s[this_idx] != other._sha1s[other_idx]:
1052
 
                raise errors.WeaveTextDiffers(name, self, other)
 
798
                raise WeaveError("inconsistent texts for version {%s} "
 
799
                                 "when joining weaves"
 
800
                                 % (name))
1053
801
            self_parents = self._parents[this_idx]
1054
802
            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):
 
803
            n1 = [self._names[i] for i in self_parents]
 
804
            n2 = [other._names[i] for i in other_parents]
 
805
            n1.sort()
 
806
            n2.sort()
 
807
            if n1 != n2:
1058
808
                raise WeaveParentMismatch("inconsistent parents "
1059
809
                    "for version {%s}: %s vs %s" % (name, n1, n2))
1060
810
            else:
1062
812
        else:
1063
813
            return False
1064
814
 
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."""
 
815
    def reweave(self, other):
 
816
        """Reweave self with other."""
 
817
        new_weave = reweave(self, other)
1082
818
        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):
 
819
            setattr(self, attr, getattr(new_weave, attr))
 
820
 
 
821
 
 
822
def reweave(wa, wb):
1160
823
    """Combine two weaves and return the result.
1161
824
 
1162
825
    This works even if a revision R has different parents in 
1167
830
    might be possible but it should only be necessary to do 
1168
831
    this operation rarely, when a new previously ghost version is 
1169
832
    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
833
    """
1174
834
    wr = Weave()
1175
835
    ia = ib = 0
1176
 
    queue_a = range(wa.num_versions())
1177
 
    queue_b = range(wb.num_versions())
 
836
    queue_a = range(wa.numversions())
 
837
    queue_b = range(wb.numversions())
1178
838
    # first determine combined parents of all versions
1179
839
    # map from version name -> all parent names
1180
840
    combined_parents = _reweave_parent_graphs(wa, wb)
1181
841
    mutter("combined parents: %r", combined_parents)
1182
842
    order = topo_sort(combined_parents.iteritems())
1183
843
    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))
 
844
    for name in order:
1191
845
        if name in wa._name_map:
1192
846
            lines = wa.get_lines(name)
1193
847
            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)
 
848
                assert lines == wb.get_lines(name)
1203
849
        else:
1204
850
            lines = wb.get_lines(name)
1205
 
        wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
 
851
        wr.add(name, combined_parents[name], lines)
1206
852
    return wr
1207
853
 
 
854
 
1208
855
def _reweave_parent_graphs(wa, wb):
1209
856
    """Return combined parent ancestry for two weaves.
1210
857
    
1213
860
    for weave in [wa, wb]:
1214
861
        for idx, name in enumerate(weave._names):
1215
862
            p = combined.setdefault(name, set())
1216
 
            p.update(map(weave._idx_to_name, weave._parents[idx]))
 
863
            p.update(map(weave.idx_to_name, weave._parents[idx]))
1217
864
    return combined
1218
865
 
1219
866
 
1223
870
    for i in (6, 50, 10, 10):
1224
871
        print '-' * i,
1225
872
    print
1226
 
    for i in range(w.num_versions()):
 
873
    for i in range(w.numversions()):
1227
874
        sha1 = w._sha1s[i]
1228
875
        name = w._names[i]
1229
876
        parent_str = ' '.join(map(str, w._parents[i]))
1276
923
        Add NEWTEXT, with specified parent versions.
1277
924
    weave annotate WEAVEFILE VERSION
1278
925
        Display origin of each line.
 
926
    weave mash WEAVEFILE VERSION...
 
927
        Display composite of all selected versions.
1279
928
    weave merge WEAVEFILE VERSION1 VERSION2 > OUT
1280
929
        Auto-merge two versions and display conflicts.
1281
930
    weave diff WEAVEFILE VERSION1 VERSION2 
1355
1004
        w = readit()
1356
1005
        sys.stdout.writelines(w.get_iter(int(argv[3])))
1357
1006
        
 
1007
    elif cmd == 'mash': # get composite
 
1008
        w = readit()
 
1009
        sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
 
1010
 
1358
1011
    elif cmd == 'diff':
 
1012
        from difflib import unified_diff
1359
1013
        w = readit()
1360
1014
        fn = argv[2]
1361
1015
        v1, v2 = map(int, argv[3:5])
1362
1016
        lines1 = w.get(v1)
1363
1017
        lines2 = w.get(v2)
1364
 
        diff_gen = bzrlib.patiencediff.unified_diff(lines1, lines2,
 
1018
        diff_gen = unified_diff(lines1, lines2,
1365
1019
                                '%s version %d' % (fn, v1),
1366
1020
                                '%s version %d' % (fn, v2))
1367
1021
        sys.stdout.writelines(diff_gen)
1390
1044
        pb = ProgressBar()
1391
1045
        w.check(pb)
1392
1046
        pb.clear()
1393
 
        print '%d versions ok' % w.num_versions()
 
1047
        print '%d versions ok' % w.numversions()
1394
1048
 
1395
1049
    elif cmd == 'inclusions':
1396
1050
        w = readit()
1401
1055
        print ' '.join(map(str, w._parents[int(argv[3])]))
1402
1056
 
1403
1057
    elif cmd == 'plan-merge':
1404
 
        # replaced by 'bzr weave-plan-merge'
1405
1058
        w = readit()
1406
1059
        for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
1407
1060
            if line:
1408
1061
                print '%14s | %s' % (state, line),
 
1062
 
1409
1063
    elif cmd == 'merge':
1410
 
        # replaced by 'bzr weave-merge-text'
1411
1064
        w = readit()
1412
1065
        p = w.plan_merge(int(argv[3]), int(argv[4]))
1413
1066
        sys.stdout.writelines(w.weave_merge(p))
 
1067
            
 
1068
    elif cmd == 'mash-merge':
 
1069
        if len(argv) != 5:
 
1070
            usage()
 
1071
            return 1
 
1072
 
 
1073
        w = readit()
 
1074
        v1, v2 = map(int, argv[3:5])
 
1075
 
 
1076
        basis = w.inclusions([v1]).intersection(w.inclusions([v2]))
 
1077
 
 
1078
        base_lines = list(w.mash_iter(basis))
 
1079
        a_lines = list(w.get(v1))
 
1080
        b_lines = list(w.get(v2))
 
1081
 
 
1082
        from bzrlib.merge3 import Merge3
 
1083
        m3 = Merge3(base_lines, a_lines, b_lines)
 
1084
 
 
1085
        name_a = 'version %d' % v1
 
1086
        name_b = 'version %d' % v2
 
1087
        sys.stdout.writelines(m3.merge_lines(name_a=name_a, name_b=name_b))
1414
1088
    else:
1415
1089
        raise ValueError('unknown command %r' % cmd)
1416
1090
    
1417
1091
 
 
1092
 
 
1093
def profile_main(argv): 
 
1094
    import tempfile, hotshot, hotshot.stats
 
1095
 
 
1096
    prof_f = tempfile.NamedTemporaryFile()
 
1097
 
 
1098
    prof = hotshot.Profile(prof_f.name)
 
1099
 
 
1100
    ret = prof.runcall(main, argv)
 
1101
    prof.close()
 
1102
 
 
1103
    stats = hotshot.stats.load(prof_f.name)
 
1104
    #stats.strip_dirs()
 
1105
    stats.sort_stats('cumulative')
 
1106
    ## XXX: Might like to write to stderr or the trace file instead but
 
1107
    ## print_stats seems hardcoded to stdout
 
1108
    stats.print_stats(20)
 
1109
            
 
1110
    return ret
 
1111
 
 
1112
 
1418
1113
if __name__ == '__main__':
1419
1114
    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)
 
1115
    if '--profile' in sys.argv:
 
1116
        args = sys.argv[:]
 
1117
        args.remove('--profile')
 
1118
        sys.exit(profile_main(args))
 
1119
    else:
 
1120
        sys.exit(main(sys.argv))
 
1121