~bzr-pqm/bzr/bzr.dev

import bisect

import binascii

import errno

import os

from stat import S_IEXEC

import stat

    def update_by_delta(self, delta):

        """Apply an inventory delta to the dirstate for tree 0

 

        :param delta: An inventory delta.  See Inventory.apply_delta for

            details.

        """

        self._read_dirblocks_if_needed()

        insertions = {}

        removals = {}

            if (file_id in insertions) or (file_id in removals):

                raise errors.InconsistentDelta(old_path or new_path, file_id,

                    "repeated file_id")

            if old_path is not None:

                old_path = old_path.encode('utf-8')

                removals[file_id] = old_path

            if new_path is not None:

                new_path = new_path.encode('utf-8')

                minikind = DirState._kind_to_minikind[inv_entry.kind]

                if minikind == 't':

                    fingerprint = inv_entry.reference_revision

                                                  child_basename)

                    insertions[child[0][2]] = (key, minikind, executable,

                                               fingerprint, new_child_path)

 

    def _apply_removals(self, removals):

            dirname, basename = osutils.split(path)

            block_i, entry_i, d_present, f_present = \

                self._get_block_entry_index(dirname, basename, 0)

            self._make_absent(entry)

            # See if we have a malformed delta: deleting a directory must not

            # leave crud behind. This increases the number of bisects needed

                # be due to it being in a parent tree, or a corrupt delta.

                for child_entry in self._dirblocks[block_i][1]:

                    if child_entry[1][0][0] not in ('r', 'a'):

                        raise errors.InconsistentDelta(path, entry[0][2],

                            "The file id was deleted but its children were "

                            "not deleted.")

 

    def _apply_insertions(self, adds):

 

    def update_basis_by_delta(self, delta, new_revid):

        """Update the parents of this tree after a commit.

        # At the same time, to reduce interface friction we convert the input

        # inventory entries to dirstate.

        root_only = ('', '')

        # items or items placed under files/links/tree-references. We get

        # references from every item in the delta that is not a deletion and

        # is not itself the root.

        parents = set()

        for old_path, new_path, file_id, inv_entry in delta:

            if inv_entry is not None and file_id != inv_entry.file_id:

                raise errors.InconsistentDelta(new_path, file_id,

                    "mismatched entry file_id %r" % inv_entry)

            if new_path is not None:

                new_path_utf8 = encode(new_path)

                # note the parent for validation

                dirname_utf8, basename_utf8 = osutils.split(new_path_utf8)

            if old_path is None:

                adds.append((None, encode(new_path), file_id,

                    inv_to_entry(inv_entry), True))

            elif new_path is None:

                deletes.append((encode(old_path), None, file_id, None, True))

            elif (old_path, new_path) != root_only:

                # of everything.

                changes.append((encode(old_path), encode(new_path), file_id,

                    inv_to_entry(inv_entry)))

        try:

            # Finish expunging deletes/first half of renames.

            self._update_basis_apply_deletes(deletes)

            # Apply in-situ changes.

            self._update_basis_apply_changes(changes)

            # Validate parents

        except errors.BzrError, e:

            if 'integrity error' not in str(e):

                raise

            # _get_entry raises BzrError when a request is inconsistent; we

            # fits the behaviour we trigger. Partof this is driven by dirstate

            # only supporting deltas that turn the basis into a closer fit to

            # the active tree.

            raise errors.InconsistentDeltaDelta(delta, "error from _get_entry.")

 

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        self._id_index = None

        return

 

    def _update_basis_apply_adds(self, adds):

        """Apply a sequence of adds to tree 1 during update_basis_by_delta.

 

        null = DirState.NULL_PARENT_DETAILS

        for old_path, new_path, file_id, _, real_delete in deletes:

            if real_delete != (new_path is None):

                raise AssertionError("bad delete delta")

            # the entry for this file_id must be in tree 1.

            dirname, basename = osutils.split(old_path)

                    # it is being resurrected here, so blank it out temporarily.

                    self._dirblocks[block_index][1][entry_index][1][1] = null

 

        for dirname_utf8, file_id in parents:

            # Get the entry - the ensures that file_id, dirname_utf8 exists and

            # has the right file id.

            if entry[1] is None:

                self._changes_aborted = True

                raise errors.InconsistentDelta(dirname_utf8.decode('utf8'),

                    file_id, "This parent is not present.")

            # Parents of things must be directories

                self._changes_aborted = True

                raise errors.InconsistentDelta(dirname_utf8.decode('utf8'),

                    file_id, "This parent is not a directory.")

        if 'evil' in debug.debug_flags:

            trace.mutter_callsite(1,

                "set_state_from_inventory called; please mutate the tree instead")

        self._read_dirblocks_if_needed()

        # sketch:

        # Two iterators: current data and new data, both in dirblock order.

        new_iterator = new_inv.iter_entries_by_dir()

        # we will be modifying the dirstate, so we need a stable iterator. In

        # future we might write one, for now we just clone the state into a

        old_iterator = iter(list(self._iter_entries()))

        # both must have roots so this is safe:

        current_new = new_iterator.next()

            # we make both end conditions explicit

            if not current_old:

                # old is finished: insert current_new into the state.

                self.update_minimal(new_entry_key, current_new_minikind,

                    executable=current_new[1].executable,

                current_new = advance(new_iterator)

            elif not current_new:

                # new is finished

                self._make_absent(current_old)

                current_old = advance(old_iterator)

            elif new_entry_key == current_old[0]:

                # kind has changed.

                if (current_old[1][0][3] != current_new[1].executable or

                    current_old[1][0][0] != current_new_minikind):

                    self.update_minimal(current_old[0], current_new_minikind,

                        executable=current_new[1].executable,

                # both sides are dealt with, move on

                current_old = advance(old_iterator)

                current_new = advance(new_iterator)

                      and new_entry_key[1:] < current_old[0][1:])):

                # new comes before:

                # add a entry for this and advance new

                self.update_minimal(new_entry_key, current_new_minikind,

                    executable=current_new[1].executable,

                current_new = advance(new_iterator)

            else:

                # we've advanced past the place where the old key would be,

                # without seeing it in the new list.  so it must be gone.

                self._make_absent(current_old)

                current_old = advance(old_iterator)

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

        self._id_index = None

        self._packed_stat_index = None

 

    def _make_absent(self, current_old):

        """Mark current_old - an entry - as absent for tree 0.

        return last_reference

 

    def update_minimal(self, key, minikind, executable=False, fingerprint='',

        """Update an entry to the state in tree 0.

 

        This will either create a new entry at 'key' or update an existing one.

        :param size: Size information for new entry

        :param path_utf8: key[0] + '/' + key[1], just passed in to avoid doing

                extra computation.

 

        If packed_stat and fingerprint are not given, they're invalidated in

        the entry.

        new_details = (minikind, fingerprint, size, executable, packed_stat)

        id_index = self._get_id_index()

        if not present:

            # new entry, synthesis cross reference here,

            existing_keys = id_index.setdefault(key[2], set())

            if not existing_keys:

                # grab one of them and use it to generate parent

                # relocation/absent entries.

                new_entry = key, [new_details]

                    # change the record at other to be a pointer to this new

                    # record. The loop looks similar to the change to

                    # relocations when updating an existing record but its not:

                    # the test for existing kinds is different: this can be

                    # factored out to a helper though.

                    if path_utf8 is None:

                        raise AssertionError('no path')

 

                num_present_parents = self._num_present_parents()

                for lookup_index in xrange(1, num_present_parents + 1):

                    # grab any one entry, use it to find the right path.

                    # TODO: optimise this to reduce memory use in highly

                    update_entry_index, present = \

                        self._find_entry_index(other_key, self._dirblocks[update_block_index][1])

                    if not present:

                    update_details = self._dirblocks[update_block_index][1][update_entry_index][1][lookup_index]

                    if update_details[0] in 'ar': # relocated, absent

                        # its a pointer or absent in lookup_index's tree, use

 

        self._dirblock_state = DirState.IN_MEMORY_MODIFIED

 

    def _validate(self):

        """Check that invariants on the dirblock are correct.