← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/weave.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/weave.py
1
 
# Copyright (C) 2005, 2009 Canonical Ltd
 
1
#! /usr/bin/python
 
2
 
 
3
# Copyright (C) 2005 Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
# Author: Martin Pool <mbp@canonical.com>
18
20
 
59
61
# where the basis and destination are unchanged.
60
62
 
61
63
# FIXME: Sometimes we will be given a parents list for a revision
62
 
# that includes some redundant parents (i.e. already a parent of
63
 
# something in the list.)  We should eliminate them.  This can
 
64
# that includes some redundant parents (i.e. already a parent of 
 
65
# something in the list.)  We should eliminate them.  This can 
64
66
# be done fairly efficiently because the sequence numbers constrain
65
67
# the possible relationships.
66
68
 
69
71
from copy import copy
70
72
from cStringIO import StringIO
71
73
import os
 
74
import sha
72
75
import time
73
76
import warnings
74
77
 
75
 
from bzrlib.lazy_import import lazy_import
76
 
lazy_import(globals(), """
77
 
from bzrlib import tsort
78
 
""")
79
 
from bzrlib import (
80
 
    errors,
81
 
    osutils,
82
 
    progress,
83
 
    )
 
78
from bzrlib.trace import mutter
84
79
from bzrlib.errors import (WeaveError, WeaveFormatError, WeaveParentMismatch,
85
80
        RevisionAlreadyPresent,
86
81
        RevisionNotPresent,
87
 
        UnavailableRepresentation,
88
82
        WeaveRevisionAlreadyPresent,
89
83
        WeaveRevisionNotPresent,
90
84
        )
91
 
from bzrlib.osutils import dirname, sha, sha_strings, split_lines
 
85
import bzrlib.errors as errors
 
86
from bzrlib.osutils import sha_strings
92
87
import bzrlib.patiencediff
93
 
from bzrlib.revision import NULL_REVISION
94
 
from bzrlib.symbol_versioning import *
95
 
from bzrlib.trace import mutter
96
 
from bzrlib.versionedfile import (
97
 
    AbsentContentFactory,
98
 
    adapter_registry,
99
 
    ContentFactory,
100
 
    sort_groupcompress,
101
 
    VersionedFile,
102
 
    )
 
88
from bzrlib.symbol_versioning import (deprecated_method,
 
89
        deprecated_function,
 
90
        zero_eight,
 
91
        )
 
92
from bzrlib.tsort import topo_sort
 
93
from bzrlib.versionedfile import VersionedFile, InterVersionedFile
103
94
from bzrlib.weavefile import _read_weave_v5, write_weave_v5
104
95
 
105
96
 
106
 
class WeaveContentFactory(ContentFactory):
107
 
    """Content factory for streaming from weaves.
108
 
 
109
 
    :seealso ContentFactory:
110
 
    """
111
 
 
112
 
    def __init__(self, version, weave):
113
 
        """Create a WeaveContentFactory for version from weave."""
114
 
        ContentFactory.__init__(self)
115
 
        self.sha1 = weave.get_sha1s([version])[version]
116
 
        self.key = (version,)
117
 
        parents = weave.get_parent_map([version])[version]
118
 
        self.parents = tuple((parent,) for parent in parents)
119
 
        self.storage_kind = 'fulltext'
120
 
        self._weave = weave
121
 
 
122
 
    def get_bytes_as(self, storage_kind):
123
 
        if storage_kind == 'fulltext':
124
 
            return self._weave.get_text(self.key[-1])
125
 
        elif storage_kind == 'chunked':
126
 
            return self._weave.get_lines(self.key[-1])
127
 
        else:
128
 
            raise UnavailableRepresentation(self.key, storage_kind, 'fulltext')
129
 
 
130
 
 
131
97
class Weave(VersionedFile):
132
98
    """weave - versioned text file storage.
133
 
 
 
99
    
134
100
    A Weave manages versions of line-based text files, keeping track
135
101
    of the originating version for each line.
136
102
 
182
148
 
183
149
    * It doesn't seem very useful to have an active insertion
184
150
      inside an inactive insertion, but it might happen.
185
 
 
 
151
      
186
152
    * Therefore, all instructions are always"considered"; that
187
153
      is passed onto and off the stack.  An outer inactive block
188
154
      doesn't disable an inner block.
218
184
    """
219
185
 
220
186
    __slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
221
 
                 '_weave_name', '_matcher', '_allow_reserved']
222
 
 
223
 
    def __init__(self, weave_name=None, access_mode='w', matcher=None,
224
 
                 get_scope=None, allow_reserved=False):
225
 
        """Create a weave.
226
 
 
227
 
        :param get_scope: A callable that returns an opaque object to be used
228
 
            for detecting when this weave goes out of scope (should stop
229
 
            answering requests or allowing mutation).
230
 
        """
231
 
        super(Weave, self).__init__()
 
187
                 '_weave_name', '_matcher']
 
188
    
 
189
    def __init__(self, weave_name=None, access_mode='w', matcher=None):
 
190
        super(Weave, self).__init__(access_mode)
232
191
        self._weave = []
233
192
        self._parents = []
234
193
        self._sha1s = []
239
198
            self._matcher = bzrlib.patiencediff.PatienceSequenceMatcher
240
199
        else:
241
200
            self._matcher = matcher
242
 
        if get_scope is None:
243
 
            get_scope = lambda:None
244
 
        self._get_scope = get_scope
245
 
        self._scope = get_scope()
246
 
        self._access_mode = access_mode
247
 
        self._allow_reserved = allow_reserved
248
201
 
249
202
    def __repr__(self):
250
203
        return "Weave(%r)" % self._weave_name
251
204
 
252
 
    def _check_write_ok(self):
253
 
        """Is the versioned file marked as 'finished' ? Raise if it is."""
254
 
        if self._get_scope() != self._scope:
255
 
            raise errors.OutSideTransaction()
256
 
        if self._access_mode != 'w':
257
 
            raise errors.ReadOnlyObjectDirtiedError(self)
258
 
 
259
205
    def copy(self):
260
206
        """Return a deep copy of self.
261
 
 
 
207
        
262
208
        The copy can be modified without affecting the original weave."""
263
209
        other = Weave()
264
210
        other._weave = self._weave[:]
274
220
            return False
275
221
        return self._parents == other._parents \
276
222
               and self._weave == other._weave \
277
 
               and self._sha1s == other._sha1s
278
 
 
 
223
               and self._sha1s == other._sha1s 
 
224
    
279
225
    def __ne__(self, other):
280
226
        return not self.__eq__(other)
281
227
 
 
228
    @deprecated_method(zero_eight)
 
229
    def idx_to_name(self, index):
 
230
        """Old public interface, the public interface is all names now."""
 
231
        return index
 
232
 
282
233
    def _idx_to_name(self, version):
283
234
        return self._names[version]
284
235
 
 
236
    @deprecated_method(zero_eight)
 
237
    def lookup(self, name):
 
238
        """Backwards compatibility thunk:
 
239
 
 
240
        Return name, as name is valid in the api now, and spew deprecation
 
241
        warnings everywhere.
 
242
        """
 
243
        return name
 
244
 
285
245
    def _lookup(self, name):
286
246
        """Convert symbolic version name to index."""
287
 
        if not self._allow_reserved:
288
 
            self.check_not_reserved_id(name)
289
247
        try:
290
248
            return self._name_map[name]
291
249
        except KeyError:
292
250
            raise RevisionNotPresent(name, self._weave_name)
293
251
 
 
252
    @deprecated_method(zero_eight)
 
253
    def iter_names(self):
 
254
        """Deprecated convenience function, please see VersionedFile.names()."""
 
255
        return iter(self.names())
 
256
 
 
257
    @deprecated_method(zero_eight)
 
258
    def names(self):
 
259
        """See Weave.versions for the current api."""
 
260
        return self.versions()
 
261
 
294
262
    def versions(self):
295
263
        """See VersionedFile.versions."""
296
264
        return self._names[:]
297
265
 
298
266
    def has_version(self, version_id):
299
267
        """See VersionedFile.has_version."""
300
 
        return (version_id in self._name_map)
 
268
        return self._name_map.has_key(version_id)
301
269
 
302
270
    __contains__ = has_version
303
271
 
304
 
    def get_record_stream(self, versions, ordering, include_delta_closure):
305
 
        """Get a stream of records for versions.
306
 
 
307
 
        :param versions: The versions to include. Each version is a tuple
308
 
            (version,).
309
 
        :param ordering: Either 'unordered' or 'topological'. A topologically
310
 
            sorted stream has compression parents strictly before their
311
 
            children.
312
 
        :param include_delta_closure: If True then the closure across any
313
 
            compression parents will be included (in the opaque data).
314
 
        :return: An iterator of ContentFactory objects, each of which is only
315
 
            valid until the iterator is advanced.
316
 
        """
317
 
        versions = [version[-1] for version in versions]
318
 
        if ordering == 'topological':
319
 
            parents = self.get_parent_map(versions)
320
 
            new_versions = tsort.topo_sort(parents)
321
 
            new_versions.extend(set(versions).difference(set(parents)))
322
 
            versions = new_versions
323
 
        elif ordering == 'groupcompress':
324
 
            parents = self.get_parent_map(versions)
325
 
            new_versions = sort_groupcompress(parents)
326
 
            new_versions.extend(set(versions).difference(set(parents)))
327
 
            versions = new_versions
328
 
        for version in versions:
329
 
            if version in self:
330
 
                yield WeaveContentFactory(version, self)
331
 
            else:
332
 
                yield AbsentContentFactory((version,))
333
 
 
334
 
    def get_parent_map(self, version_ids):
335
 
        """See VersionedFile.get_parent_map."""
336
 
        result = {}
 
272
    def get_delta(self, version_id):
 
273
        """See VersionedFile.get_delta."""
 
274
        return self.get_deltas([version_id])[version_id]
 
275
 
 
276
    def get_deltas(self, version_ids):
 
277
        """See VersionedFile.get_deltas."""
 
278
        version_ids = self.get_ancestry(version_ids)
337
279
        for version_id in version_ids:
338
 
            if version_id == NULL_REVISION:
339
 
                parents = ()
340
 
            else:
341
 
                try:
342
 
                    parents = tuple(
343
 
                        map(self._idx_to_name,
344
 
                            self._parents[self._lookup(version_id)]))
345
 
                except RevisionNotPresent:
 
280
            if not self.has_version(version_id):
 
281
                raise RevisionNotPresent(version_id, self)
 
282
        # try extracting all versions; parallel extraction is used
 
283
        nv = self.num_versions()
 
284
        sha1s = {}
 
285
        deltas = {}
 
286
        texts = {}
 
287
        inclusions = {}
 
288
        noeols = {}
 
289
        last_parent_lines = {}
 
290
        parents = {}
 
291
        parent_inclusions = {}
 
292
        parent_linenums = {}
 
293
        parent_noeols = {}
 
294
        current_hunks = {}
 
295
        diff_hunks = {}
 
296
        # its simplest to generate a full set of prepared variables.
 
297
        for i in range(nv):
 
298
            name = self._names[i]
 
299
            sha1s[name] = self.get_sha1(name)
 
300
            parents_list = self.get_parents(name)
 
301
            try:
 
302
                parent = parents_list[0]
 
303
                parents[name] = parent
 
304
                parent_inclusions[name] = inclusions[parent]
 
305
            except IndexError:
 
306
                parents[name] = None
 
307
                parent_inclusions[name] = set()
 
308
            # we want to emit start, finish, replacement_length, replacement_lines tuples.
 
309
            diff_hunks[name] = []
 
310
            current_hunks[name] = [0, 0, 0, []] # #start, finish, repl_length, repl_tuples
 
311
            parent_linenums[name] = 0
 
312
            noeols[name] = False
 
313
            parent_noeols[name] = False
 
314
            last_parent_lines[name] = None
 
315
            new_inc = set([name])
 
316
            for p in self._parents[i]:
 
317
                new_inc.update(inclusions[self._idx_to_name(p)])
 
318
            # debug only, known good so far.
 
319
            #assert set(new_inc) == set(self.get_ancestry(name)), \
 
320
            #    'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
 
321
            inclusions[name] = new_inc
 
322
 
 
323
        nlines = len(self._weave)
 
324
 
 
325
        for lineno, inserted, deletes, line in self._walk_internal():
 
326
            # a line is active in a version if:
 
327
            # insert is in the versions inclusions
 
328
            # and
 
329
            # deleteset & the versions inclusions is an empty set.
 
330
            # so - if we have a included by mapping - version is included by
 
331
            # children, we get a list of children to examine for deletes affect
 
332
            # ing them, which is less than the entire set of children.
 
333
            for version_id in version_ids:  
 
334
                # The active inclusion must be an ancestor,
 
335
                # and no ancestors must have deleted this line,
 
336
                # because we don't support resurrection.
 
337
                parent_inclusion = parent_inclusions[version_id]
 
338
                inclusion = inclusions[version_id]
 
339
                parent_active = inserted in parent_inclusion and not (deletes & parent_inclusion)
 
340
                version_active = inserted in inclusion and not (deletes & inclusion)
 
341
                if not parent_active and not version_active:
 
342
                    # unrelated line of ancestry
346
343
                    continue
347
 
            result[version_id] = parents
 
344
                elif parent_active and version_active:
 
345
                    # shared line
 
346
                    parent_linenum = parent_linenums[version_id]
 
347
                    if current_hunks[version_id] != [parent_linenum, parent_linenum, 0, []]:
 
348
                        diff_hunks[version_id].append(tuple(current_hunks[version_id]))
 
349
                    parent_linenum += 1
 
350
                    current_hunks[version_id] = [parent_linenum, parent_linenum, 0, []]
 
351
                    parent_linenums[version_id] = parent_linenum
 
352
                    try:
 
353
                        if line[-1] != '\n':
 
354
                            noeols[version_id] = True
 
355
                    except IndexError:
 
356
                        pass
 
357
                elif parent_active and not version_active:
 
358
                    # deleted line
 
359
                    current_hunks[version_id][1] += 1
 
360
                    parent_linenums[version_id] += 1
 
361
                    last_parent_lines[version_id] = line
 
362
                elif not parent_active and version_active:
 
363
                    # replacement line
 
364
                    # noeol only occurs at the end of a file because we 
 
365
                    # diff linewise. We want to show noeol changes as a
 
366
                    # empty diff unless the actual eol-less content changed.
 
367
                    theline = line
 
368
                    try:
 
369
                        if last_parent_lines[version_id][-1] != '\n':
 
370
                            parent_noeols[version_id] = True
 
371
                    except (TypeError, IndexError):
 
372
                        pass
 
373
                    try:
 
374
                        if theline[-1] != '\n':
 
375
                            noeols[version_id] = True
 
376
                    except IndexError:
 
377
                        pass
 
378
                    new_line = False
 
379
                    parent_should_go = False
 
380
 
 
381
                    if parent_noeols[version_id] == noeols[version_id]:
 
382
                        # no noeol toggle, so trust the weaves statement
 
383
                        # that this line is changed.
 
384
                        new_line = True
 
385
                        if parent_noeols[version_id]:
 
386
                            theline = theline + '\n'
 
387
                    elif parent_noeols[version_id]:
 
388
                        # parent has no eol, we do:
 
389
                        # our line is new, report as such..
 
390
                        new_line = True
 
391
                    elif noeols[version_id]:
 
392
                        # append a eol so that it looks like
 
393
                        # a normalised delta
 
394
                        theline = theline + '\n'
 
395
                        if parents[version_id] is not None:
 
396
                        #if last_parent_lines[version_id] is not None:
 
397
                            parent_should_go = True
 
398
                        if last_parent_lines[version_id] != theline:
 
399
                            # but changed anyway
 
400
                            new_line = True
 
401
                            #parent_should_go = False
 
402
                    if new_line:
 
403
                        current_hunks[version_id][2] += 1
 
404
                        current_hunks[version_id][3].append((inserted, theline))
 
405
                    if parent_should_go:
 
406
                        # last hunk last parent line is not eaten
 
407
                        current_hunks[version_id][1] -= 1
 
408
                    if current_hunks[version_id][1] < 0:
 
409
                        current_hunks[version_id][1] = 0
 
410
                        # import pdb;pdb.set_trace()
 
411
                    # assert current_hunks[version_id][1] >= 0
 
412
 
 
413
        # flush last hunk
 
414
        for i in range(nv):
 
415
            version = self._idx_to_name(i)
 
416
            if current_hunks[version] != [0, 0, 0, []]:
 
417
                diff_hunks[version].append(tuple(current_hunks[version]))
 
418
        result = {}
 
419
        for version_id in version_ids:
 
420
            result[version_id] = (
 
421
                                  parents[version_id],
 
422
                                  sha1s[version_id],
 
423
                                  noeols[version_id],
 
424
                                  diff_hunks[version_id],
 
425
                                  )
348
426
        return result
349
427
 
350
 
    def get_parents_with_ghosts(self, version_id):
351
 
        raise NotImplementedError(self.get_parents_with_ghosts)
352
 
 
353
 
    def insert_record_stream(self, stream):
354
 
        """Insert a record stream into this versioned file.
355
 
 
356
 
        :param stream: A stream of records to insert.
357
 
        :return: None
358
 
        :seealso VersionedFile.get_record_stream:
359
 
        """
360
 
        adapters = {}
361
 
        for record in stream:
362
 
            # Raise an error when a record is missing.
363
 
            if record.storage_kind == 'absent':
364
 
                raise RevisionNotPresent([record.key[0]], self)
365
 
            # adapt to non-tuple interface
366
 
            parents = [parent[0] for parent in record.parents]
367
 
            if (record.storage_kind == 'fulltext'
368
 
                or record.storage_kind == 'chunked'):
369
 
                self.add_lines(record.key[0], parents,
370
 
                    osutils.chunks_to_lines(record.get_bytes_as('chunked')))
371
 
            else:
372
 
                adapter_key = record.storage_kind, 'fulltext'
373
 
                try:
374
 
                    adapter = adapters[adapter_key]
375
 
                except KeyError:
376
 
                    adapter_factory = adapter_registry.get(adapter_key)
377
 
                    adapter = adapter_factory(self)
378
 
                    adapters[adapter_key] = adapter
379
 
                lines = split_lines(adapter.get_bytes(record))
380
 
                try:
381
 
                    self.add_lines(record.key[0], parents, lines)
382
 
                except RevisionAlreadyPresent:
383
 
                    pass
 
428
    def get_parents(self, version_id):
 
429
        """See VersionedFile.get_parent."""
 
430
        return map(self._idx_to_name, self._parents[self._lookup(version_id)])
384
431
 
385
432
    def _check_repeated_add(self, name, parents, text, sha1):
386
433
        """Check that a duplicated add is OK.
393
440
            raise RevisionAlreadyPresent(name, self._weave_name)
394
441
        return idx
395
442
 
396
 
    def _add_lines(self, version_id, parents, lines, parent_texts,
397
 
       left_matching_blocks, nostore_sha, random_id, check_content):
 
443
    @deprecated_method(zero_eight)
 
444
    def add_identical(self, old_rev_id, new_rev_id, parents):
 
445
        """Please use Weave.clone_text now."""
 
446
        return self.clone_text(new_rev_id, old_rev_id, parents)
 
447
 
 
448
    def _add_lines(self, version_id, parents, lines, parent_texts):
398
449
        """See VersionedFile.add_lines."""
399
 
        idx = self._add(version_id, lines, map(self._lookup, parents),
400
 
            nostore_sha=nostore_sha)
401
 
        return sha_strings(lines), sum(map(len, lines)), idx
402
 
 
403
 
    def _add(self, version_id, lines, parents, sha1=None, nostore_sha=None):
 
450
        return self._add(version_id, lines, map(self._lookup, parents))
 
451
 
 
452
    @deprecated_method(zero_eight)
 
453
    def add(self, name, parents, text, sha1=None):
 
454
        """See VersionedFile.add_lines for the non deprecated api."""
 
455
        return self._add(name, text, map(self._maybe_lookup, parents), sha1)
 
456
 
 
457
    def _add(self, version_id, lines, parents, sha1=None):
404
458
        """Add a single text on top of the weave.
405
 
 
 
459
  
406
460
        Returns the index number of the newly added version.
407
461
 
408
462
        version_id
409
463
            Symbolic name for this version.
410
464
            (Typically the revision-id of the revision that added it.)
411
 
            If None, a name will be allocated based on the hash. (sha1:SHAHASH)
412
465
 
413
466
        parents
414
467
            List or set of direct parent version numbers.
415
 
 
 
468
            
416
469
        lines
417
470
            Sequence of lines to be added in the new version.
 
471
        """
418
472
 
419
 
        :param nostore_sha: See VersionedFile.add_lines.
420
 
        """
 
473
        assert isinstance(version_id, basestring)
421
474
        self._check_lines_not_unicode(lines)
422
475
        self._check_lines_are_lines(lines)
423
476
        if not sha1:
424
477
            sha1 = sha_strings(lines)
425
 
        if sha1 == nostore_sha:
426
 
            raise errors.ExistingContent
427
 
        if version_id is None:
428
 
            version_id = "sha1:" + sha1
429
478
        if version_id in self._name_map:
430
479
            return self._check_repeated_add(version_id, parents, lines, sha1)
431
480
 
442
491
        self._names.append(version_id)
443
492
        self._name_map[version_id] = new_version
444
493
 
445
 
 
 
494
            
446
495
        if not parents:
447
496
            # special case; adding with no parents revision; can do
448
497
            # this more quickly by just appending unconditionally.
459
508
            if sha1 == self._sha1s[pv]:
460
509
                # special case: same as the single parent
461
510
                return new_version
462
 
 
 
511
            
463
512
 
464
513
        ancestors = self._inclusions(parents)
465
514
 
475
524
        # another small special case: a merge, producing the same text
476
525
        # as auto-merge
477
526
        if lines == basis_lines:
478
 
            return new_version
 
527
            return new_version            
479
528
 
480
529
        # add a sentinel, because we can also match against the final line
481
530
        basis_lineno.append(len(self._weave))
500
549
            #print 'raw match', tag, i1, i2, j1, j2
501
550
            if tag == 'equal':
502
551
                continue
 
552
 
503
553
            i1 = basis_lineno[i1]
504
554
            i2 = basis_lineno[i2]
 
555
 
 
556
            assert 0 <= j1 <= j2 <= len(lines)
 
557
 
 
558
            #print tag, i1, i2, j1, j2
 
559
 
505
560
            # the deletion and insertion are handled separately.
506
561
            # first delete the region.
507
562
            if i1 != i2:
514
569
                # i2; we want to insert after this region to make sure
515
570
                # we don't destroy ourselves
516
571
                i = i2 + offset
517
 
                self._weave[i:i] = ([('{', new_version)]
518
 
                                    + lines[j1:j2]
 
572
                self._weave[i:i] = ([('{', new_version)] 
 
573
                                    + lines[j1:j2] 
519
574
                                    + [('}', None)])
520
575
                offset += 2 + (j2 - j1)
521
576
        return new_version
522
577
 
 
578
    def _clone_text(self, new_version_id, old_version_id, parents):
 
579
        """See VersionedFile.clone_text."""
 
580
        old_lines = self.get_text(old_version_id)
 
581
        self.add_lines(new_version_id, parents, old_lines)
 
582
 
523
583
    def _inclusions(self, versions):
524
584
        """Return set of all ancestors of given version(s)."""
525
585
        if not len(versions):
533
593
        ## except IndexError:
534
594
        ##     raise ValueError("version %d not present in weave" % v)
535
595
 
536
 
    def get_ancestry(self, version_ids, topo_sorted=True):
 
596
    @deprecated_method(zero_eight)
 
597
    def inclusions(self, version_ids):
 
598
        """Deprecated - see VersionedFile.get_ancestry for the replacement."""
 
599
        if not version_ids:
 
600
            return []
 
601
        if isinstance(version_ids[0], int):
 
602
            return [self._idx_to_name(v) for v in self._inclusions(version_ids)]
 
603
        else:
 
604
            return self.get_ancestry(version_ids)
 
605
 
 
606
    def get_ancestry(self, version_ids):
537
607
        """See VersionedFile.get_ancestry."""
538
608
        if isinstance(version_ids, basestring):
539
609
            version_ids = [version_ids]
548
618
            if not isinstance(l, basestring):
549
619
                raise ValueError("text line should be a string or unicode, not %s"
550
620
                                 % type(l))
551
 
 
 
621
        
552
622
 
553
623
 
554
624
    def _check_versions(self, indexes):
562
632
    def _compatible_parents(self, my_parents, other_parents):
563
633
        """During join check that other_parents are joinable with my_parents.
564
634
 
565
 
        Joinable is defined as 'is a subset of' - supersets may require
 
635
        Joinable is defined as 'is a subset of' - supersets may require 
566
636
        regeneration of diffs, but subsets do not.
567
637
        """
568
638
        return len(other_parents.difference(my_parents)) == 0
569
639
 
570
640
    def annotate(self, version_id):
571
 
        """Return a list of (version-id, line) tuples for version_id.
 
641
        if isinstance(version_id, int):
 
642
            warnings.warn('Weave.annotate(int) is deprecated. Please use version names'
 
643
                 ' in all circumstances as of 0.8',
 
644
                 DeprecationWarning,
 
645
                 stacklevel=2
 
646
                 )
 
647
            result = []
 
648
            for origin, lineno, text in self._extract([version_id]):
 
649
                result.append((origin, text))
 
650
            return result
 
651
        else:
 
652
            return super(Weave, self).annotate(version_id)
 
653
    
 
654
    def annotate_iter(self, version_id):
 
655
        """Yield list of (version-id, line) pairs for the specified version.
572
656
 
573
657
        The index indicates when the line originated in the weave."""
574
658
        incls = [self._lookup(version_id)]
575
 
        return [(self._idx_to_name(origin), text) for origin, lineno, text in
576
 
            self._extract(incls)]
577
 
 
578
 
    def iter_lines_added_or_present_in_versions(self, version_ids=None,
579
 
                                                pb=None):
 
659
        for origin, lineno, text in self._extract(incls):
 
660
            yield self._idx_to_name(origin), text
 
661
 
 
662
    @deprecated_method(zero_eight)
 
663
    def _walk(self):
 
664
        """_walk has become visit, a supported api."""
 
665
        return self._walk_internal()
 
666
 
 
667
    def iter_lines_added_or_present_in_versions(self, version_ids=None):
580
668
        """See VersionedFile.iter_lines_added_or_present_in_versions()."""
581
669
        if version_ids is None:
582
670
            version_ids = self.versions()
583
671
        version_ids = set(version_ids)
584
672
        for lineno, inserted, deletes, line in self._walk_internal(version_ids):
585
 
            if inserted not in version_ids: continue
 
673
            # if inserted not in version_ids then it was inserted before the
 
674
            # versions we care about, but because weaves cannot represent ghosts
 
675
            # properly, we do not filter down to that
 
676
            # if inserted not in version_ids: continue
586
677
            if line[-1] != '\n':
587
 
                yield line + '\n', inserted
 
678
                yield line + '\n'
588
679
            else:
589
 
                yield line, inserted
 
680
                yield line
 
681
 
 
682
    #@deprecated_method(zero_eight)
 
683
    def walk(self, version_ids=None):
 
684
        """See VersionedFile.walk."""
 
685
        return self._walk_internal(version_ids)
590
686
 
591
687
    def _walk_internal(self, version_ids=None):
592
688
        """Helper method for weave actions."""
593
 
 
 
689
        
594
690
        istack = []
595
691
        dset = set()
596
692
 
605
701
                elif c == '}':
606
702
                    istack.pop()
607
703
                elif c == '[':
 
704
                    assert self._names[v] not in dset
608
705
                    dset.add(self._names[v])
609
706
                elif c == ']':
610
707
                    dset.remove(self._names[v])
611
708
                else:
612
709
                    raise WeaveFormatError('unexpected instruction %r' % v)
613
710
            else:
 
711
                assert l.__class__ in (str, unicode)
 
712
                assert istack
614
713
                yield lineno, istack[-1], frozenset(dset), l
615
714
            lineno += 1
616
715
 
633
732
        inc_b = set(self.get_ancestry([ver_b]))
634
733
        inc_c = inc_a & inc_b
635
734
 
636
 
        for lineno, insert, deleteset, line in self._walk_internal([ver_a, ver_b]):
 
735
        for lineno, insert, deleteset, line in\
 
736
            self.walk([ver_a, ver_b]):
637
737
            if deleteset & inc_c:
638
738
                # killed in parent; can't be in either a or b
639
739
                # not relevant to our work
665
765
                # not in either revision
666
766
                yield 'irrelevant', line
667
767
 
 
768
        yield 'unchanged', ''           # terminator
 
769
 
668
770
    def _extract(self, versions):
669
771
        """Yield annotation of lines in included set.
670
772
 
677
779
        for i in versions:
678
780
            if not isinstance(i, int):
679
781
                raise ValueError(i)
680
 
 
 
782
            
681
783
        included = self._inclusions(versions)
682
784
 
683
785
        istack = []
692
794
 
693
795
        WFE = WeaveFormatError
694
796
 
695
 
        # wow.
 
797
        # wow. 
696
798
        #  449       0   4474.6820   2356.5590   bzrlib.weave:556(_extract)
697
799
        #  +285282   0   1676.8040   1676.8040   +<isinstance>
698
800
        # 1.6 seconds in 'isinstance'.
704
806
        # we're still spending ~1/4 of the method in isinstance though.
705
807
        # so lets hard code the acceptable string classes we expect:
706
808
        #  449       0   1202.9420    786.2930   bzrlib.weave:556(_extract)
707
 
        # +71352     0    377.5560    377.5560   +<method 'append' of 'list'
 
809
        # +71352     0    377.5560    377.5560   +<method 'append' of 'list' 
708
810
        #                                          objects>
709
811
        # yay, down to ~1/4 the initial extract time, and our inline time
710
812
        # has shrunk again, with isinstance no longer dominating.
711
813
        # tweaking the stack inclusion test to use a set gives:
712
814
        #  449       0   1122.8030    713.0080   bzrlib.weave:556(_extract)
713
 
        # +71352     0    354.9980    354.9980   +<method 'append' of 'list'
 
815
        # +71352     0    354.9980    354.9980   +<method 'append' of 'list' 
714
816
        #                                          objects>
715
817
        # - a 5% win, or possibly just noise. However with large istacks that
716
818
        # 'in' test could dominate, so I'm leaving this change in place -
717
819
        # when its fast enough to consider profiling big datasets we can review.
718
820
 
719
 
 
720
 
 
 
821
              
 
822
             
721
823
 
722
824
        for l in self._weave:
723
825
            if l.__class__ == tuple:
724
826
                c, v = l
725
827
                isactive = None
726
828
                if c == '{':
 
829
                    assert v not in iset
727
830
                    istack.append(v)
728
831
                    iset.add(v)
729
832
                elif c == '}':
730
833
                    iset.remove(istack.pop())
731
834
                elif c == '[':
732
835
                    if v in included:
 
836
                        assert v not in dset
733
837
                        dset.add(v)
734
 
                elif c == ']':
 
838
                else:
 
839
                    assert c == ']'
735
840
                    if v in included:
 
841
                        assert v in dset
736
842
                        dset.remove(v)
737
 
                else:
738
 
                    raise AssertionError()
739
843
            else:
 
844
                assert l.__class__ in (str, unicode)
740
845
                if isactive is None:
741
846
                    isactive = (not dset) and istack and (istack[-1] in included)
742
847
                if isactive:
750
855
                                   % dset)
751
856
        return result
752
857
 
 
858
    @deprecated_method(zero_eight)
 
859
    def get_iter(self, name_or_index):
 
860
        """Deprecated, please do not use. Lookups are not not needed.
 
861
        
 
862
        Please use get_lines now.
 
863
        """
 
864
        return iter(self.get_lines(self._maybe_lookup(name_or_index)))
 
865
 
 
866
    @deprecated_method(zero_eight)
 
867
    def maybe_lookup(self, name_or_index):
 
868
        """Deprecated, please do not use. Lookups are not not needed."""
 
869
        return self._maybe_lookup(name_or_index)
 
870
 
753
871
    def _maybe_lookup(self, name_or_index):
754
872
        """Convert possible symbolic name to index, or pass through indexes.
755
 
 
 
873
        
756
874
        NOT FOR PUBLIC USE.
757
875
        """
758
876
        if isinstance(name_or_index, (int, long)):
760
878
        else:
761
879
            return self._lookup(name_or_index)
762
880
 
 
881
    @deprecated_method(zero_eight)
 
882
    def get(self, version_id):
 
883
        """Please use either Weave.get_text or Weave.get_lines as desired."""
 
884
        return self.get_lines(version_id)
 
885
 
763
886
    def get_lines(self, version_id):
764
887
        """See VersionedFile.get_lines()."""
765
888
        int_index = self._maybe_lookup(version_id)
768
891
        measured_sha1 = sha_strings(result)
769
892
        if measured_sha1 != expected_sha1:
770
893
            raise errors.WeaveInvalidChecksum(
771
 
                    'file %s, revision %s, expected: %s, measured %s'
 
894
                    'file %s, revision %s, expected: %s, measured %s' 
772
895
                    % (self._weave_name, version_id,
773
896
                       expected_sha1, measured_sha1))
774
897
        return result
775
898
 
776
 
    def get_sha1s(self, version_ids):
777
 
        """See VersionedFile.get_sha1s()."""
778
 
        result = {}
779
 
        for v in version_ids:
780
 
            result[v] = self._sha1s[self._lookup(v)]
781
 
        return result
 
899
    def get_sha1(self, version_id):
 
900
        """See VersionedFile.get_sha1()."""
 
901
        return self._sha1s[self._lookup(version_id)]
 
902
 
 
903
    @deprecated_method(zero_eight)
 
904
    def numversions(self):
 
905
        """How many versions are in this weave?
 
906
 
 
907
        Deprecated in favour of num_versions.
 
908
        """
 
909
        return self.num_versions()
782
910
 
783
911
    def num_versions(self):
784
912
        """How many versions are in this weave?"""
785
913
        l = len(self._parents)
 
914
        assert l == len(self._sha1s)
786
915
        return l
787
916
 
788
917
    __len__ = num_versions
808
937
            # For creating the ancestry, IntSet is much faster (3.7s vs 0.17s)
809
938
            # The problem is that set membership is much more expensive
810
939
            name = self._idx_to_name(i)
811
 
            sha1s[name] = sha()
 
940
            sha1s[name] = sha.new()
812
941
            texts[name] = []
813
942
            new_inc = set([name])
814
943
            for p in self._parents[i]:
815
944
                new_inc.update(inclusions[self._idx_to_name(p)])
816
945
 
817
 
            if set(new_inc) != set(self.get_ancestry(name)):
818
 
                raise AssertionError(
819
 
                    'failed %s != %s'
820
 
                    % (set(new_inc), set(self.get_ancestry(name))))
 
946
            assert set(new_inc) == set(self.get_ancestry(name)), \
 
947
                'failed %s != %s' % (set(new_inc), set(self.get_ancestry(name)))
821
948
            inclusions[name] = new_inc
822
949
 
823
950
        nlines = len(self._weave)
853
980
        # no lines outside of insertion blocks, that deletions are
854
981
        # properly paired, etc.
855
982
 
 
983
    def _join(self, other, pb, msg, version_ids, ignore_missing):
 
984
        """Worker routine for join()."""
 
985
        if not other.versions():
 
986
            return          # nothing to update, easy
 
987
 
 
988
        if not version_ids:
 
989
            # versions is never none, InterWeave checks this.
 
990
            return 0
 
991
 
 
992
        # two loops so that we do not change ourselves before verifying it
 
993
        # will be ok
 
994
        # work through in index order to make sure we get all dependencies
 
995
        names_to_join = []
 
996
        processed = 0
 
997
        # get the selected versions only that are in other.versions.
 
998
        version_ids = set(other.versions()).intersection(set(version_ids))
 
999
        # pull in the referenced graph.
 
1000
        version_ids = other.get_ancestry(version_ids)
 
1001
        pending_graph = [(version, other.get_parents(version)) for
 
1002
                         version in version_ids]
 
1003
        for name in topo_sort(pending_graph):
 
1004
            other_idx = other._name_map[name]
 
1005
            # returns True if we have it, False if we need it.
 
1006
            if not self._check_version_consistent(other, other_idx, name):
 
1007
                names_to_join.append((other_idx, name))
 
1008
            processed += 1
 
1009
 
 
1010
 
 
1011
        if pb and not msg:
 
1012
            msg = 'weave join'
 
1013
 
 
1014
        merged = 0
 
1015
        time0 = time.time()
 
1016
        for other_idx, name in names_to_join:
 
1017
            # TODO: If all the parents of the other version are already
 
1018
            # present then we can avoid some work by just taking the delta
 
1019
            # and adjusting the offsets.
 
1020
            new_parents = self._imported_parents(other, other_idx)
 
1021
            sha1 = other._sha1s[other_idx]
 
1022
 
 
1023
            merged += 1
 
1024
 
 
1025
            if pb:
 
1026
                pb.update(msg, merged, len(names_to_join))
 
1027
           
 
1028
            lines = other.get_lines(other_idx)
 
1029
            self._add(name, lines, new_parents, sha1)
 
1030
 
 
1031
        mutter("merged = %d, processed = %d, file_id=%s; deltat=%d"%(
 
1032
                merged, processed, self._weave_name, time.time()-time0))
 
1033
 
856
1034
    def _imported_parents(self, other, other_idx):
857
1035
        """Return list of parents in self corresponding to indexes in other."""
858
1036
        new_parents = []
860
1038
            parent_name = other._names[parent_idx]
861
1039
            if parent_name not in self._name_map:
862
1040
                # should not be possible
863
 
                raise WeaveError("missing parent {%s} of {%s} in %r"
 
1041
                raise WeaveError("missing parent {%s} of {%s} in %r" 
864
1042
                                 % (parent_name, other._name_map[other_idx], self))
865
1043
            new_parents.append(self._name_map[parent_name])
866
1044
        return new_parents
873
1051
         * the same text
874
1052
         * the same direct parents (by name, not index, and disregarding
875
1053
           order)
876
 
 
 
1054
        
877
1055
        If present & correct return True;
878
 
        if not present in self return False;
 
1056
        if not present in self return False; 
879
1057
        if inconsistent raise error."""
880
1058
        this_idx = self._name_map.get(name, -1)
881
1059
        if this_idx != -1:
893
1071
        else:
894
1072
            return False
895
1073
 
 
1074
    @deprecated_method(zero_eight)
 
1075
    def reweave(self, other, pb=None, msg=None):
 
1076
        """reweave has been superseded by plain use of join."""
 
1077
        return self.join(other, pb, msg)
 
1078
 
896
1079
    def _reweave(self, other, pb, msg):
897
1080
        """Reweave self with other - internal helper for join().
898
1081
 
914
1097
    """A WeaveFile represents a Weave on disk and writes on change."""
915
1098
 
916
1099
    WEAVE_SUFFIX = '.weave'
917
 
 
918
 
    def __init__(self, name, transport, filemode=None, create=False, access_mode='w', get_scope=None):
 
1100
    
 
1101
    def __init__(self, name, transport, filemode=None, create=False, access_mode='w'):
919
1102
        """Create a WeaveFile.
920
 
 
 
1103
        
921
1104
        :param create: If not True, only open an existing knit.
922
1105
        """
923
 
        super(WeaveFile, self).__init__(name, access_mode, get_scope=get_scope,
924
 
            allow_reserved=False)
 
1106
        super(WeaveFile, self).__init__(name, access_mode)
925
1107
        self._transport = transport
926
1108
        self._filemode = filemode
927
1109
        try:
932
1114
            # new file, save it
933
1115
            self._save()
934
1116
 
935
 
    def _add_lines(self, version_id, parents, lines, parent_texts,
936
 
        left_matching_blocks, nostore_sha, random_id, check_content):
 
1117
    def _add_lines(self, version_id, parents, lines, parent_texts):
937
1118
        """Add a version and save the weave."""
938
 
        self.check_not_reserved_id(version_id)
939
1119
        result = super(WeaveFile, self)._add_lines(version_id, parents, lines,
940
 
            parent_texts, left_matching_blocks, nostore_sha, random_id,
941
 
            check_content)
 
1120
                                                   parent_texts)
942
1121
        self._save()
943
1122
        return result
944
1123
 
 
1124
    def _clone_text(self, new_version_id, old_version_id, parents):
 
1125
        """See VersionedFile.clone_text."""
 
1126
        super(WeaveFile, self)._clone_text(new_version_id, old_version_id, parents)
 
1127
        self._save
 
1128
 
945
1129
    def copy_to(self, name, transport):
946
1130
        """See VersionedFile.copy_to()."""
947
1131
        # as we are all in memory always, just serialise to the new place.
948
1132
        sio = StringIO()
949
1133
        write_weave_v5(self, sio)
950
1134
        sio.seek(0)
951
 
        transport.put_file(name + WeaveFile.WEAVE_SUFFIX, sio, self._filemode)
 
1135
        transport.put(name + WeaveFile.WEAVE_SUFFIX, sio, self._filemode)
 
1136
 
 
1137
    def create_empty(self, name, transport, filemode=None):
 
1138
        return WeaveFile(name, transport, filemode, create=True)
952
1139
 
953
1140
    def _save(self):
954
1141
        """Save the weave."""
956
1143
        sio = StringIO()
957
1144
        write_weave_v5(self, sio)
958
1145
        sio.seek(0)
959
 
        bytes = sio.getvalue()
960
 
        path = self._weave_name + WeaveFile.WEAVE_SUFFIX
961
 
        try:
962
 
            self._transport.put_bytes(path, bytes, self._filemode)
963
 
        except errors.NoSuchFile:
964
 
            self._transport.mkdir(dirname(path))
965
 
            self._transport.put_bytes(path, bytes, self._filemode)
 
1146
        self._transport.put(self._weave_name + WeaveFile.WEAVE_SUFFIX,
 
1147
                            sio,
 
1148
                            self._filemode)
966
1149
 
967
1150
    @staticmethod
968
1151
    def get_suffixes():
969
1152
        """See VersionedFile.get_suffixes()."""
970
1153
        return [WeaveFile.WEAVE_SUFFIX]
971
1154
 
972
 
    def insert_record_stream(self, stream):
973
 
        super(WeaveFile, self).insert_record_stream(stream)
 
1155
    def join(self, other, pb=None, msg=None, version_ids=None,
 
1156
             ignore_missing=False):
 
1157
        """Join other into self and save."""
 
1158
        super(WeaveFile, self).join(other, pb, msg, version_ids, ignore_missing)
974
1159
        self._save()
975
1160
 
976
1161
 
 
1162
@deprecated_function(zero_eight)
 
1163
def reweave(wa, wb, pb=None, msg=None):
 
1164
    """reweaving is deprecation, please just use weave.join()."""
 
1165
    _reweave(wa, wb, pb, msg)
 
1166
 
977
1167
def _reweave(wa, wb, pb=None, msg=None):
978
1168
    """Combine two weaves and return the result.
979
1169
 
980
 
    This works even if a revision R has different parents in
 
1170
    This works even if a revision R has different parents in 
981
1171
    wa and wb.  In the resulting weave all the parents are given.
982
1172
 
983
 
    This is done by just building up a new weave, maintaining ordering
 
1173
    This is done by just building up a new weave, maintaining ordering 
984
1174
    of the versions in the two inputs.  More efficient approaches
985
 
    might be possible but it should only be necessary to do
986
 
    this operation rarely, when a new previously ghost version is
 
1175
    might be possible but it should only be necessary to do 
 
1176
    this operation rarely, when a new previously ghost version is 
987
1177
    inserted.
988
1178
 
989
1179
    :param pb: An optional progress bar, indicating how far done we are
997
1187
    # map from version name -> all parent names
998
1188
    combined_parents = _reweave_parent_graphs(wa, wb)
999
1189
    mutter("combined parents: %r", combined_parents)
1000
 
    order = tsort.topo_sort(combined_parents.iteritems())
 
1190
    order = topo_sort(combined_parents.iteritems())
1001
1191
    mutter("order to reweave: %r", order)
1002
1192
 
1003
1193
    if pb and not msg:
1023
1213
        wr._add(name, lines, [wr._lookup(i) for i in combined_parents[name]])
1024
1214
    return wr
1025
1215
 
1026
 
 
1027
1216
def _reweave_parent_graphs(wa, wb):
1028
1217
    """Return combined parent ancestry for two weaves.
1029
 
 
 
1218
    
1030
1219
    Returned as a list of (version_name, set(parent_names))"""
1031
1220
    combined = {}
1032
1221
    for weave in [wa, wb]:
1034
1223
            p = combined.setdefault(name, set())
1035
1224
            p.update(map(weave._idx_to_name, weave._parents[idx]))
1036
1225
    return combined
 
1226
 
 
1227
 
 
1228
def weave_toc(w):
 
1229
    """Show the weave's table-of-contents"""
 
1230
    print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
 
1231
    for i in (6, 50, 10, 10):
 
1232
        print '-' * i,
 
1233
    print
 
1234
    for i in range(w.num_versions()):
 
1235
        sha1 = w._sha1s[i]
 
1236
        name = w._names[i]
 
1237
        parent_str = ' '.join(map(str, w._parents[i]))
 
1238
        print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
 
1239
 
 
1240
 
 
1241
 
 
1242
def weave_stats(weave_file, pb):
 
1243
    from bzrlib.weavefile import read_weave
 
1244
 
 
1245
    wf = file(weave_file, 'rb')
 
1246
    w = read_weave(wf)
 
1247
    # FIXME: doesn't work on pipes
 
1248
    weave_size = wf.tell()
 
1249
 
 
1250
    total = 0
 
1251
    vers = len(w)
 
1252
    for i in range(vers):
 
1253
        pb.update('checking sizes', i, vers)
 
1254
        for origin, lineno, line in w._extract([i]):
 
1255
            total += len(line)
 
1256
 
 
1257
    pb.clear()
 
1258
 
 
1259
    print 'versions          %9d' % vers
 
1260
    print 'weave file        %9d bytes' % weave_size
 
1261
    print 'total contents    %9d bytes' % total
 
1262
    print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
 
1263
    if vers:
 
1264
        avg = total/vers
 
1265
        print 'average size      %9d bytes' % avg
 
1266
        print 'relative size     %9.2fx' % (float(weave_size) / float(avg))
 
1267
 
 
1268
 
 
1269
def usage():
 
1270
    print """bzr weave tool
 
1271
 
 
1272
Experimental tool for weave algorithm.
 
1273
 
 
1274
usage:
 
1275
    weave init WEAVEFILE
 
1276
        Create an empty weave file
 
1277
    weave get WEAVEFILE VERSION
 
1278
        Write out specified version.
 
1279
    weave check WEAVEFILE
 
1280
        Check consistency of all versions.
 
1281
    weave toc WEAVEFILE
 
1282
        Display table of contents.
 
1283
    weave add WEAVEFILE NAME [BASE...] < NEWTEXT
 
1284
        Add NEWTEXT, with specified parent versions.
 
1285
    weave annotate WEAVEFILE VERSION
 
1286
        Display origin of each line.
 
1287
    weave merge WEAVEFILE VERSION1 VERSION2 > OUT
 
1288
        Auto-merge two versions and display conflicts.
 
1289
    weave diff WEAVEFILE VERSION1 VERSION2 
 
1290
        Show differences between two versions.
 
1291
 
 
1292
example:
 
1293
 
 
1294
    % weave init foo.weave
 
1295
    % vi foo.txt
 
1296
    % weave add foo.weave ver0 < foo.txt
 
1297
    added version 0
 
1298
 
 
1299
    (create updated version)
 
1300
    % vi foo.txt
 
1301
    % weave get foo.weave 0 | diff -u - foo.txt
 
1302
    % weave add foo.weave ver1 0 < foo.txt
 
1303
    added version 1
 
1304
 
 
1305
    % weave get foo.weave 0 > foo.txt       (create forked version)
 
1306
    % vi foo.txt
 
1307
    % weave add foo.weave ver2 0 < foo.txt
 
1308
    added version 2
 
1309
 
 
1310
    % weave merge foo.weave 1 2 > foo.txt   (merge them)
 
1311
    % vi foo.txt                            (resolve conflicts)
 
1312
    % weave add foo.weave merged 1 2 < foo.txt     (commit merged version)     
 
1313
    
 
1314
"""
 
1315
    
 
1316
 
 
1317
 
 
1318
def main(argv):
 
1319
    import sys
 
1320
    import os
 
1321
    try:
 
1322
        import bzrlib
 
1323
    except ImportError:
 
1324
        # in case we're run directly from the subdirectory
 
1325
        sys.path.append('..')
 
1326
        import bzrlib
 
1327
    from bzrlib.weavefile import write_weave, read_weave
 
1328
    from bzrlib.progress import ProgressBar
 
1329
 
 
1330
    try:
 
1331
        import psyco
 
1332
        psyco.full()
 
1333
    except ImportError:
 
1334
        pass
 
1335
 
 
1336
    if len(argv) < 2:
 
1337
        usage()
 
1338
        return 0
 
1339
 
 
1340
    cmd = argv[1]
 
1341
 
 
1342
    def readit():
 
1343
        return read_weave(file(argv[2], 'rb'))
 
1344
    
 
1345
    if cmd == 'help':
 
1346
        usage()
 
1347
    elif cmd == 'add':
 
1348
        w = readit()
 
1349
        # at the moment, based on everything in the file
 
1350
        name = argv[3]
 
1351
        parents = map(int, argv[4:])
 
1352
        lines = sys.stdin.readlines()
 
1353
        ver = w.add(name, parents, lines)
 
1354
        write_weave(w, file(argv[2], 'wb'))
 
1355
        print 'added version %r %d' % (name, ver)
 
1356
    elif cmd == 'init':
 
1357
        fn = argv[2]
 
1358
        if os.path.exists(fn):
 
1359
            raise IOError("file exists")
 
1360
        w = Weave()
 
1361
        write_weave(w, file(fn, 'wb'))
 
1362
    elif cmd == 'get': # get one version
 
1363
        w = readit()
 
1364
        sys.stdout.writelines(w.get_iter(int(argv[3])))
 
1365
        
 
1366
    elif cmd == 'diff':
 
1367
        w = readit()
 
1368
        fn = argv[2]
 
1369
        v1, v2 = map(int, argv[3:5])
 
1370
        lines1 = w.get(v1)
 
1371
        lines2 = w.get(v2)
 
1372
        diff_gen = bzrlib.patiencediff.unified_diff(lines1, lines2,
 
1373
                                '%s version %d' % (fn, v1),
 
1374
                                '%s version %d' % (fn, v2))
 
1375
        sys.stdout.writelines(diff_gen)
 
1376
            
 
1377
    elif cmd == 'annotate':
 
1378
        w = readit()
 
1379
        # newline is added to all lines regardless; too hard to get
 
1380
        # reasonable formatting otherwise
 
1381
        lasto = None
 
1382
        for origin, text in w.annotate(int(argv[3])):
 
1383
            text = text.rstrip('\r\n')
 
1384
            if origin == lasto:
 
1385
                print '      | %s' % (text)
 
1386
            else:
 
1387
                print '%5d | %s' % (origin, text)
 
1388
                lasto = origin
 
1389
                
 
1390
    elif cmd == 'toc':
 
1391
        weave_toc(readit())
 
1392
 
 
1393
    elif cmd == 'stats':
 
1394
        weave_stats(argv[2], ProgressBar())
 
1395
        
 
1396
    elif cmd == 'check':
 
1397
        w = readit()
 
1398
        pb = ProgressBar()
 
1399
        w.check(pb)
 
1400
        pb.clear()
 
1401
        print '%d versions ok' % w.num_versions()
 
1402
 
 
1403
    elif cmd == 'inclusions':
 
1404
        w = readit()
 
1405
        print ' '.join(map(str, w.inclusions([int(argv[3])])))
 
1406
 
 
1407
    elif cmd == 'parents':
 
1408
        w = readit()
 
1409
        print ' '.join(map(str, w._parents[int(argv[3])]))
 
1410
 
 
1411
    elif cmd == 'plan-merge':
 
1412
        # replaced by 'bzr weave-plan-merge'
 
1413
        w = readit()
 
1414
        for state, line in w.plan_merge(int(argv[3]), int(argv[4])):
 
1415
            if line:
 
1416
                print '%14s | %s' % (state, line),
 
1417
    elif cmd == 'merge':
 
1418
        # replaced by 'bzr weave-merge-text'
 
1419
        w = readit()
 
1420
        p = w.plan_merge(int(argv[3]), int(argv[4]))
 
1421
        sys.stdout.writelines(w.weave_merge(p))
 
1422
    else:
 
1423
        raise ValueError('unknown command %r' % cmd)
 
1424
    
 
1425
 
 
1426
if __name__ == '__main__':
 
1427
    import sys
 
1428
    sys.exit(main(sys.argv))
 
1429
 
 
1430
 
 
1431
class InterWeave(InterVersionedFile):
 
1432
    """Optimised code paths for weave to weave operations."""
 
1433
    
 
1434
    _matching_file_from_factory = staticmethod(WeaveFile)
 
1435
    _matching_file_to_factory = staticmethod(WeaveFile)
 
1436
    
 
1437
    @staticmethod
 
1438
    def is_compatible(source, target):
 
1439
        """Be compatible with weaves."""
 
1440
        try:
 
1441
            return (isinstance(source, Weave) and
 
1442
                    isinstance(target, Weave))
 
1443
        except AttributeError:
 
1444
            return False
 
1445
 
 
1446
    def join(self, pb=None, msg=None, version_ids=None, ignore_missing=False):
 
1447
        """See InterVersionedFile.join."""
 
1448
        version_ids = self._get_source_version_ids(version_ids, ignore_missing)
 
1449
        if self.target.versions() == [] and version_ids is None:
 
1450
            self.target._copy_weave_content(self.source)
 
1451
            return
 
1452
        try:
 
1453
            self.target._join(self.source, pb, msg, version_ids, ignore_missing)
 
1454
        except errors.WeaveParentMismatch:
 
1455
            self.target._reweave(self.source, pb, msg)
 
1456
 
 
1457
 
 
1458
InterVersionedFile.register_optimiser(InterWeave)