~bzr-pqm/bzr/bzr.dev

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

 

# Author: Martin Pool <mbp@canonical.com>

 

"""Weave - storage of related text file versions"""

 

 

# XXX: If we do weaves this way, will a merge still behave the same

# way if it's done in a different order?  That's a pretty desirable

# where the basis and destination are unchanged.

 

# FIXME: Sometimes we will be given a parents list for a revision

# be done fairly efficiently because the sequence numbers constrain

# the possible relationships.

 

from copy import copy

from cStringIO import StringIO

import os

 

from bzrlib import (

    )

from bzrlib.errors import (WeaveError, WeaveFormatError, WeaveParentMismatch,

        RevisionAlreadyPresent,

        RevisionNotPresent,

        )

import bzrlib.patiencediff

from bzrlib.weavefile import _read_weave_v5, write_weave_v5

 

 

class Weave(VersionedFile):

    """weave - versioned text file storage.

    A Weave manages versions of line-based text files, keeping track

    of the originating version for each line.

 

 

    * It doesn't seem very useful to have an active insertion

      inside an inactive insertion, but it might happen.

    * Therefore, all instructions are always"considered"; that

      is passed onto and off the stack.  An outer inactive block

      doesn't disable an inner block.

    """

 

    __slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',

        """Create a weave.

 

        :param get_scope: A callable that returns an opaque object to be used

            for detecting when this weave goes out of scope (should stop

            answering requests or allowing mutation).

        """

        self._weave = []

        self._parents = []

        self._sha1s = []

        self._get_scope = get_scope

        self._scope = get_scope()

        self._access_mode = access_mode

 

    def __repr__(self):

        return "Weave(%r)" % self._weave_name

 

    def copy(self):

        """Return a deep copy of self.

        The copy can be modified without affecting the original weave."""

        other = Weave()

        other._weave = self._weave[:]

            return False

        return self._parents == other._parents \

               and self._weave == other._weave \

    def __ne__(self, other):

        return not self.__eq__(other)

 

 

    def _lookup(self, name):

        """Convert symbolic version name to index."""

        try:

            return self._name_map[name]

        except KeyError:

 

    __contains__ = has_version

 

    def get_parent_map(self, version_ids):

        """See VersionedFile.get_parent_map."""

        result = {}

        for version_id in version_ids:

        return result

 

    def get_parents_with_ghosts(self, version_id):

        raise NotImplementedError(self.get_parents_with_ghosts)

 

    def _check_repeated_add(self, name, parents, text, sha1):

        """Check that a duplicated add is OK.

 

 

    def _add(self, version_id, lines, parents, sha1=None, nostore_sha=None):

        """Add a single text on top of the weave.

        Returns the index number of the newly added version.

 

        version_id

            Symbolic name for this version.

            (Typically the revision-id of the revision that added it.)

 

        parents

            List or set of direct parent version numbers.

        lines

            Sequence of lines to be added in the new version.

 

        :param nostore_sha: See VersionedFile.add_lines.

        """

        self._check_lines_not_unicode(lines)

        self._check_lines_are_lines(lines)

        if not sha1:

            sha1 = sha_strings(lines)

        if sha1 == nostore_sha:

            raise errors.ExistingContent

        if version_id in self._name_map:

            return self._check_repeated_add(version_id, parents, lines, sha1)

 

        self._names.append(version_id)

        self._name_map[version_id] = new_version

 

        if not parents:

            # special case; adding with no parents revision; can do

            # this more quickly by just appending unconditionally.

            if sha1 == self._sha1s[pv]:

                # special case: same as the single parent

                return new_version

 

        ancestors = self._inclusions(parents)

 

            #print 'raw match', tag, i1, i2, j1, j2

            if tag == 'equal':

                continue

            i1 = basis_lineno[i1]

            i2 = basis_lineno[i2]

            # the deletion and insertion are handled separately.

            # first delete the region.

            if i1 != i2:

                # i2; we want to insert after this region to make sure

                # we don't destroy ourselves

                i = i2 + offset

                                    + [('}', None)])

                offset += 2 + (j2 - j1)

        return new_version

            if not isinstance(l, basestring):

                raise ValueError("text line should be a string or unicode, not %s"

                                 % type(l))

 

 

    def _check_versions(self, indexes):

    def _compatible_parents(self, my_parents, other_parents):

        """During join check that other_parents are joinable with my_parents.

 

        regeneration of diffs, but subsets do not.

        """

        return len(other_parents.difference(my_parents)) == 0

            version_ids = self.versions()

        version_ids = set(version_ids)

        for lineno, inserted, deletes, line in self._walk_internal(version_ids):

            if line[-1] != '\n':

                yield line + '\n', inserted

            else:

 

    def _walk_internal(self, version_ids=None):

        """Helper method for weave actions."""

        istack = []

        dset = set()

 

                elif c == '}':

                    istack.pop()

                elif c == '[':

                    dset.add(self._names[v])

                elif c == ']':

                    dset.remove(self._names[v])

                else:

                    raise WeaveFormatError('unexpected instruction %r' % v)

            else:

                yield lineno, istack[-1], frozenset(dset), l

            lineno += 1

 

                # not in either revision

                yield 'irrelevant', line

 

    def _extract(self, versions):

        """Yield annotation of lines in included set.

 

        for i in versions:

            if not isinstance(i, int):

                raise ValueError(i)

        included = self._inclusions(versions)

 

        istack = []

 

        WFE = WeaveFormatError

 

        #  449       0   4474.6820   2356.5590   bzrlib.weave:556(_extract)

        #  +285282   0   1676.8040   1676.8040   +<isinstance>

        # 1.6 seconds in 'isinstance'.

        # we're still spending ~1/4 of the method in isinstance though.

        # so lets hard code the acceptable string classes we expect:

        #  449       0   1202.9420    786.2930   bzrlib.weave:556(_extract)

        #                                          objects>

        # yay, down to ~1/4 the initial extract time, and our inline time

        # has shrunk again, with isinstance no longer dominating.

        # tweaking the stack inclusion test to use a set gives:

        #  449       0   1122.8030    713.0080   bzrlib.weave:556(_extract)

        #                                          objects>

        # - a 5% win, or possibly just noise. However with large istacks that

        # 'in' test could dominate, so I'm leaving this change in place -

        # when its fast enough to consider profiling big datasets we can review.

 

 

        for l in self._weave:

            if l.__class__ == tuple:

                c, v = l

                isactive = None

                if c == '{':

                    istack.append(v)

                    iset.add(v)

                elif c == '}':

                    iset.remove(istack.pop())

                elif c == '[':

                    if v in included:

                        dset.add(v)

                    if v in included:

                        dset.remove(v)

            else:

                if isactive is None:

                    isactive = (not dset) and istack and (istack[-1] in included)

                if isactive:

 

    def _maybe_lookup(self, name_or_index):

        """Convert possible symbolic name to index, or pass through indexes.

        NOT FOR PUBLIC USE.

        """

        if isinstance(name_or_index, (int, long)):

        measured_sha1 = sha_strings(result)

        if measured_sha1 != expected_sha1:

            raise errors.WeaveInvalidChecksum(

                    % (self._weave_name, version_id,

                       expected_sha1, measured_sha1))

        return result

 

    def get_sha1s(self, version_ids):

        """See VersionedFile.get_sha1s()."""

 

    def num_versions(self):

        """How many versions are in this weave?"""

        l = len(self._parents)

        return l

 

    __len__ = num_versions

            # For creating the ancestry, IntSet is much faster (3.7s vs 0.17s)

            # The problem is that set membership is much more expensive

            name = self._idx_to_name(i)

            texts[name] = []

            new_inc = set([name])

            for p in self._parents[i]:

                new_inc.update(inclusions[self._idx_to_name(p)])

 

            inclusions[name] = new_inc

 

        nlines = len(self._weave)

        # no lines outside of insertion blocks, that deletions are

        # properly paired, etc.

 

    def _imported_parents(self, other, other_idx):

        """Return list of parents in self corresponding to indexes in other."""

        new_parents = []

            parent_name = other._names[parent_idx]

            if parent_name not in self._name_map:

                # should not be possible

                                 % (parent_name, other._name_map[other_idx], self))

            new_parents.append(self._name_map[parent_name])

        return new_parents

         * the same text

         * the same direct parents (by name, not index, and disregarding

           order)

        If present & correct return True;

        if inconsistent raise error."""

        this_idx = self._name_map.get(name, -1)

        if this_idx != -1:

    """A WeaveFile represents a Weave on disk and writes on change."""

 

    WEAVE_SUFFIX = '.weave'

    def __init__(self, name, transport, filemode=None, create=False, access_mode='w', get_scope=None):

        """Create a WeaveFile.

        :param create: If not True, only open an existing knit.

        """

        self._transport = transport

        self._filemode = filemode

        try:

        except errors.NoSuchFile:

            if not create:

                raise

        sio = StringIO()

        write_weave_v5(self, sio)

        sio.seek(0)

 

    @staticmethod

    def get_suffixes():

        """See VersionedFile.get_suffixes()."""

        return [WeaveFile.WEAVE_SUFFIX]

 

        self._save()

 

 

def _reweave(wa, wb, pb=None, msg=None):

    """Combine two weaves and return the result.

 

    wa and wb.  In the resulting weave all the parents are given.

 

    of the versions in the two inputs.  More efficient approaches

    inserted.

 

    :param pb: An optional progress bar, indicating how far done we are

    # map from version name -> all parent names

    combined_parents = _reweave_parent_graphs(wa, wb)

    mutter("combined parents: %r", combined_parents)

    mutter("order to reweave: %r", order)

 

    if pb and not msg: