← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/multiparent.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-27 19:05:43 UTC
  • mto: This revision was merged to the branch mainline in revision 6450.
  • Revision ID: jelmer@samba.org-20120127190543-vk350mv4a0c7aug2
Fix weave test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/multiparent.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
from __future__ import absolute_import
16
18
 
17
19
from bzrlib.lazy_import import lazy_import
18
20
 
19
21
lazy_import(globals(), """
20
22
import errno
 
23
import gzip
21
24
import itertools
22
25
import os
23
26
from StringIO import StringIO
24
27
 
25
28
from bzrlib import (
 
29
    bencode,
26
30
    errors,
27
31
    patiencediff,
28
 
    trace,
29
32
    ui,
30
33
    )
31
 
from bzrlib.util import bencode
32
34
""")
33
 
from bzrlib.tuned_gzip import GzipFile
34
 
 
 
35
 
 
36
 
 
37
def topo_iter_keys(vf, keys=None):
 
38
    if keys is None:
 
39
        keys = vf.keys()
 
40
    parents = vf.get_parent_map(keys)
 
41
    return _topo_iter(parents, keys)
35
42
 
36
43
def topo_iter(vf, versions=None):
37
 
    seen = set()
38
 
    descendants = {}
39
44
    if versions is None:
40
45
        versions = vf.versions()
41
46
    parents = vf.get_parent_map(versions)
 
47
    return _topo_iter(parents, versions)
 
48
 
 
49
def _topo_iter(parents, versions):
 
50
    seen = set()
 
51
    descendants = {}
42
52
    def pending_parents(version):
 
53
        if parents[version] is None:
 
54
            return []
43
55
        return [v for v in parents[version] if v in versions and
44
56
                v not in seen]
45
57
    for version_id in versions:
 
58
        if parents[version_id] is None:
 
59
            # parentless
 
60
            continue
46
61
        for parent_id in parents[version_id]:
47
62
            descendants.setdefault(parent_id, []).append(version_id)
48
63
    cur = [v for v in versions if len(pending_parents(v)) == 0]
62
77
class MultiParent(object):
63
78
    """A multi-parent diff"""
64
79
 
 
80
    __slots__ = ['hunks']
 
81
 
65
82
    def __init__(self, hunks=None):
66
83
        if hunks is not None:
67
84
            self.hunks = hunks
244
261
class NewText(object):
245
262
    """The contents of text that is introduced by this text"""
246
263
 
 
264
    __slots__ = ['lines']
 
265
 
247
266
    def __init__(self, lines):
248
267
        self.lines = lines
249
268
 
265
284
class ParentText(object):
266
285
    """A reference to text present in a parent text"""
267
286
 
 
287
    __slots__ = ['parent', 'parent_pos', 'child_pos', 'num_lines']
 
288
 
268
289
    def __init__(self, parent, parent_pos, child_pos, num_lines):
269
290
        self.parent = parent
270
291
        self.parent_pos = parent_pos
271
292
        self.child_pos = child_pos
272
293
        self.num_lines = num_lines
273
294
 
 
295
    def _as_dict(self):
 
296
        return dict(parent=self.parent, parent_pos=self.parent_pos,
 
297
                    child_pos=self.child_pos, num_lines=self.num_lines)
 
298
 
274
299
    def __repr__(self):
275
 
        return 'ParentText(%(parent)r, %(parent_pos)r, %(child_pos)r,'\
276
 
            ' %(num_lines)r)' % self.__dict__
 
300
        return ('ParentText(%(parent)r, %(parent_pos)r, %(child_pos)r,'
 
301
                ' %(num_lines)r)' % self._as_dict())
277
302
 
278
303
    def __eq__(self, other):
279
 
        if self.__class__ != other.__class__:
 
304
        if self.__class__ is not other.__class__:
280
305
            return False
281
 
        return (self.__dict__ == other.__dict__)
 
306
        return self._as_dict() == other._as_dict()
282
307
 
283
308
    def to_patch(self):
284
 
        yield 'c %(parent)d %(parent_pos)d %(child_pos)d %(num_lines)d\n'\
285
 
            % self.__dict__
 
309
        yield ('c %(parent)d %(parent_pos)d %(child_pos)d %(num_lines)d\n'
 
310
               % self._as_dict())
286
311
 
287
312
 
288
313
class BaseVersionedFile(object):
302
327
        return version in self._parents
303
328
 
304
329
    def do_snapshot(self, version_id, parent_ids):
305
 
        """Determine whether to perform a a snapshot for this version"""
 
330
        """Determine whether to perform a snapshot for this version"""
306
331
        if self.snapshot_interval is None:
307
332
            return False
308
333
        if self.max_snapshots is not None and\
398
423
                            if not (lines == self.get_line_list([revision])[0]):
399
424
                                raise AssertionError()
400
425
                            self.clear_cache()
401
 
                    pb.update('Importing revisions',
 
426
                    pb.update(gettext('Importing revisions'),
402
427
                              (total - len(revisions)) + len(added), total)
403
428
                revisions = [r for r in revisions if r not in added]
404
429
        finally:
537
562
            sio = StringIO(infile.read(count))
538
563
        finally:
539
564
            infile.close()
540
 
        zip_file = GzipFile(None, mode='rb', fileobj=sio)
 
565
        zip_file = gzip.GzipFile(None, mode='rb', fileobj=sio)
541
566
        try:
542
567
            file_version_id = zip_file.readline()
543
 
            return MultiParent.from_patch(zip_file.read())
 
568
            content = zip_file.read()
 
569
            return MultiParent.from_patch(content)
544
570
        finally:
545
571
            zip_file.close()
546
572
 
552
578
                                    # before any write returns 0
553
579
            start = outfile.tell()
554
580
            try:
555
 
                zipfile = GzipFile(None, mode='ab', fileobj=outfile)
 
581
                zipfile = gzip.GzipFile(None, mode='ab', fileobj=outfile)
556
582
                zipfile.writelines(itertools.chain(
557
583
                    ['version %s\n' % version_id], diff.to_patch()))
558
584
            finally:
649
675
 
650
676
def gzip_string(lines):
651
677
    sio = StringIO()
652
 
    data_file = GzipFile(None, mode='wb', fileobj=sio)
 
678
    data_file = gzip.GzipFile(None, mode='wb', fileobj=sio)
653
679
    data_file.writelines(lines)
654
680
    data_file.close()
655
681
    return sio.getvalue()