/brz/remove-bazaar

# Copyright (C) 2005, 2006, 2007 Canonical Ltd

#

# 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

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

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

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

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

# FIXME: This refactoring of the workingtree code doesn't seem to keep

# the WorkingTree's copy of the inventory in sync with the branch.  The

# branch modifies its working inventory when it does a commit to make

# missing files permanently removed.

# TODO: Maybe also keep the full path of the entry, and the children?

# But those depend on its position within a particular inventory, and

# it would be nice not to need to hold the backpointer here.

# This should really be an id randomly assigned when the tree is

# created, but it's not for now.

ROOT_ID = "TREE_ROOT"

from copy import deepcopy

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import collections

import os

import re

import tarfile

import bzrlib

from bzrlib import (

    chk_map,

    errors,

    generate_ids,

    osutils,

    symbol_versioning,

    workingtree,

    )

""")

from bzrlib.errors import (

    BzrCheckError,

    BzrError,

    )

from bzrlib.symbol_versioning import deprecated_in, deprecated_method

from bzrlib.trace import mutter

class InventoryEntry(object):

    """Description of a versioned file.

    An InventoryEntry has the following fields, which are also

    present in the XML inventory-entry element:

    file_id

    name

        (within the parent directory)

    parent_id

        file_id of the parent directory, or ROOT_ID

    revision

        the revision_id in which this variation of this file was

        introduced.

    executable

        Indicates that this file should be executable on systems

        that support it.

    text_sha1

        sha-1 of the text of the file

    text_size

        size in bytes of the text of the file

    (reading a version 4 tree created a text_id field.)

    >>> i = Inventory()

    >>> i.path2id('')

    'TREE_ROOT'

    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))

    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)

    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))

    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None, revision=None)

    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}

    >>> for ix, j in enumerate(i.iter_entries()):

    ...   print (j[0] == shouldbe[ix], j[1])

    ...

    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))

    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))

    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None, revision=None))

    >>> i.add(InventoryFile('2324', 'bye.c', '123'))

    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None, revision=None)

    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))

    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)

    >>> i.path2id('src/wibble')

    '2325'

    >>> '2325' in i

    True

    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))

    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)

    >>> i['2326']

    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)

    >>> for path, entry in i.iter_entries():

    ...     print path

    ...

    <BLANKLINE>

    src

    src/bye.c

    src/hello.c

    src/wibble

    src/wibble/wibble.c

    >>> i.id2path('2326')

    'src/wibble/wibble.c'

    """

    # Constants returned by describe_change()

    #

    # TODO: These should probably move to some kind of FileChangeDescription

    # class; that's like what's inside a TreeDelta but we want to be able to

    # generate them just for one file at a time.

    RENAMED = 'renamed'

    MODIFIED_AND_RENAMED = 'modified and renamed'

    __slots__ = []

    def detect_changes(self, old_entry):

        """Return a (text_modified, meta_modified) from this to old_entry.

        _read_tree_state must have been called on self and old_entry prior to

        calling detect_changes.

        """

        return False, False

    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,

             output_to, reverse=False):

        """Perform a diff between two entries of the same kind."""

    def parent_candidates(self, previous_inventories):

        """Find possible per-file graph parents.

        This is currently defined by:

         - Select the last changed revision in the parent inventory.

         - Do deal with a short lived bug in bzr 0.8's development two entries

           that have the same last changed but different 'x' bit settings are

           changed in-place.

        """

        # revision:ie mapping for each ie found in previous_inventories.

        candidates = {}

        # identify candidate head revision ids.

        for inv in previous_inventories:

            if self.file_id in inv:

                ie = inv[self.file_id]

                if ie.revision in candidates:

                    # same revision value in two different inventories:

                    # correct possible inconsistencies:

                    #     * there was a bug in revision updates with 'x' bit

                    #       support.

                    try:

                        if candidates[ie.revision].executable != ie.executable:

                            candidates[ie.revision].executable = False

                            ie.executable = False

                    except AttributeError:

                        pass

                else:

                    # add this revision as a candidate.

                    candidates[ie.revision] = ie

        return candidates

    @deprecated_method(deprecated_in((1, 6, 0)))

    def get_tar_item(self, root, dp, now, tree):

        """Get a tarfile item and a file stream for its content."""

        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))

        # TODO: would be cool to actually set it to the timestamp of the

        # revision it was last changed

        item.mtime = now

        fileobj = self._put_in_tar(item, tree)

        return item, fileobj

    def has_text(self):

        """Return true if the object this entry represents has textual data.

        Note that textual data includes binary content.

        Also note that all entries get weave files created for them.

        This attribute is primarily used when upgrading from old trees that

        did not have the weave index for all inventory entries.

        """

        return False

    def __init__(self, file_id, name, parent_id, text_id=None):

        """Create an InventoryEntry

        The filename must be a single component, relative to the

        parent directory; it cannot be a whole path or relative name.

        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)

        >>> e.name

        'hello.c'

        >>> e.file_id

        '123'

        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)

        Traceback (most recent call last):

        InvalidEntryName: Invalid entry name: src/hello.c

        """

        if '/' in name or '\\' in name:

            raise errors.InvalidEntryName(name=name)

        self.executable = False

        self.revision = None

        self.text_sha1 = None

        self.text_size = None

        self.file_id = file_id

        self.name = name

        self.text_id = text_id

        self.parent_id = parent_id

        self.symlink_target = None

        self.reference_revision = None

    def kind_character(self):

        """Return a short kind indicator useful for appending to names."""

        raise BzrError('unknown kind %r' % self.kind)

    known_kinds = ('file', 'directory', 'symlink')

    def _put_in_tar(self, item, tree):

        """populate item for stashing in a tar, and return the content stream.

        If no content is available, return None.

        """

        raise BzrError("don't know how to export {%s} of kind %r" %

                       (self.file_id, self.kind))

    @deprecated_method(deprecated_in((1, 6, 0)))

    def put_on_disk(self, dest, dp, tree):

        """Create a representation of self on disk in the prefix dest.

        This is a template method - implement _put_on_disk in subclasses.

        """

        fullpath = osutils.pathjoin(dest, dp)

        self._put_on_disk(fullpath, tree)

        # mutter("  export {%s} kind %s to %s", self.file_id,

        #         self.kind, fullpath)

    def _put_on_disk(self, fullpath, tree):

        """Put this entry onto disk at fullpath, from tree tree."""

        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))

    def sorted_children(self):

        return sorted(self.children.items())

    @staticmethod

    def versionable_kind(kind):

        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))

    def check(self, checker, rev_id, inv, tree):

        """Check this inventory entry is intact.

        This is a template method, override _check for kind specific

        tests.

        :param checker: Check object providing context for the checks;

             can be used to find out what parts of the repository have already

             been checked.

        :param rev_id: Revision id from which this InventoryEntry was loaded.

             Not necessarily the last-changed revision for this file.

        :param inv: Inventory from which the entry was loaded.

        :param tree: RevisionTree for this entry.

        """

        if self.parent_id is not None:

            if not inv.has_id(self.parent_id):

                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'

                        % (self.parent_id, rev_id))

        self._check(checker, rev_id, tree)

    def _check(self, checker, rev_id, tree):

        """Check this inventory entry for kind specific errors."""

        raise BzrCheckError('unknown entry kind %r in revision {%s}' %

                            (self.kind, rev_id))

    def copy(self):

        """Clone this inventory entry."""

        raise NotImplementedError

    @staticmethod

    def describe_change(old_entry, new_entry):

        """Describe the change between old_entry and this.

        This smells of being an InterInventoryEntry situation, but as its

        the first one, we're making it a static method for now.

        An entry with a different parent, or different name is considered

        to be renamed. Reparenting is an internal detail.

        Note that renaming the parent does not trigger a rename for the

        child entry itself.

        """

        # TODO: Perhaps return an object rather than just a string

        if old_entry is new_entry:

            # also the case of both being None

            return 'unchanged'

        elif old_entry is None:

            return 'added'

        elif new_entry is None:

            return 'removed'

        if old_entry.kind != new_entry.kind:

            return 'modified'

        text_modified, meta_modified = new_entry.detect_changes(old_entry)

        if text_modified or meta_modified:

            modified = True

        else:

            modified = False

        # TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.

        if old_entry.parent_id != new_entry.parent_id:

            renamed = True

        elif old_entry.name != new_entry.name:

            renamed = True

        else:

            renamed = False

        if renamed and not modified:

            return InventoryEntry.RENAMED

        if modified and not renamed:

            return 'modified'

        if modified and renamed:

            return InventoryEntry.MODIFIED_AND_RENAMED

        return 'unchanged'

    def __repr__(self):

        return ("%s(%r, %r, parent_id=%r, revision=%r)"

                % (self.__class__.__name__,

                   self.file_id,

                   self.name,

                   self.parent_id,

                   self.revision))

    def __eq__(self, other):

        if other is self:

            # For the case when objects are cached

            return True

        if not isinstance(other, InventoryEntry):

            return NotImplemented

        return ((self.file_id == other.file_id)

                and (self.name == other.name)

                and (other.symlink_target == self.symlink_target)

                and (self.text_sha1 == other.text_sha1)

                and (self.text_size == other.text_size)

                and (self.text_id == other.text_id)

                and (self.parent_id == other.parent_id)

                and (self.kind == other.kind)

                and (self.revision == other.revision)

                and (self.executable == other.executable)

                and (self.reference_revision == other.reference_revision)

                )

    def __ne__(self, other):

        return not (self == other)

    def __hash__(self):

        raise ValueError('not hashable')

    def _unchanged(self, previous_ie):

        """Has this entry changed relative to previous_ie.

        This method should be overridden in child classes.

        """

        compatible = True

        # different inv parent

        if previous_ie.parent_id != self.parent_id:

            compatible = False

        # renamed

        elif previous_ie.name != self.name:

            compatible = False

        elif previous_ie.kind != self.kind:

            compatible = False

        return compatible

    def _read_tree_state(self, path, work_tree):

        """Populate fields in the inventory entry from the given tree.

        Note that this should be modified to be a noop on virtual trees

        as all entries created there are prepopulated.

        """

        # TODO: Rather than running this manually, we should check the

        # working sha1 and other expensive properties when they're

        # first requested, or preload them if they're already known

        pass            # nothing to do by default

    def _forget_tree_state(self):

        pass

class RootEntry(InventoryEntry):

    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',

                 'text_id', 'parent_id', 'children', 'executable',

                 'revision', 'symlink_target', 'reference_revision']

    def _check(self, checker, rev_id, tree):

        """See InventoryEntry._check"""

    def __init__(self, file_id):

        self.file_id = file_id

        self.children = {}

        self.kind = 'directory'

        self.parent_id = None

        self.name = u''

        self.revision = None

        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'

                               '  Please use InventoryDirectory instead.',

                               DeprecationWarning, stacklevel=2)

    def __eq__(self, other):

        if not isinstance(other, RootEntry):

            return NotImplemented

        return (self.file_id == other.file_id) \

               and (self.children == other.children)

class InventoryDirectory(InventoryEntry):

    """A directory in an inventory."""

    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',

                 'text_id', 'parent_id', 'children', 'executable',

                 'revision', 'symlink_target', 'reference_revision']

    def _check(self, checker, rev_id, tree):

        """See InventoryEntry._check"""

        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:

            raise BzrCheckError('directory {%s} has text in revision {%s}'

                                % (self.file_id, rev_id))

    def copy(self):

        other = InventoryDirectory(self.file_id, self.name, self.parent_id)

        other.revision = self.revision

        # note that children are *not* copied; they're pulled across when

        # others are added

        return other

    def __init__(self, file_id, name, parent_id):

        super(InventoryDirectory, self).__init__(file_id, name, parent_id)

        self.children = {}

        self.kind = 'directory'

    def kind_character(self):

        """See InventoryEntry.kind_character."""

        return '/'

    def _put_in_tar(self, item, tree):

        """See InventoryEntry._put_in_tar."""

        item.type = tarfile.DIRTYPE

        fileobj = None

        item.name += '/'

        item.size = 0

        item.mode = 0755

        return fileobj

    def _put_on_disk(self, fullpath, tree):

        """See InventoryEntry._put_on_disk."""

        os.mkdir(fullpath)

class InventoryFile(InventoryEntry):

    """A file in an inventory."""

    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',

                 'text_id', 'parent_id', 'children', 'executable',

                 'revision', 'symlink_target', 'reference_revision']

    def _check(self, checker, tree_revision_id, tree):

        """See InventoryEntry._check"""

        key = (self.file_id, self.revision)

        if key in checker.checked_texts:

            prev_sha = checker.checked_texts[key]

            if prev_sha != self.text_sha1:

                raise BzrCheckError(

                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %

                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,

                     t))

            else:

                checker.repeated_text_cnt += 1

                return

        checker.checked_text_cnt += 1

        # We can't check the length, because Weave doesn't store that

        # information, and the whole point of looking at the weave's

        # sha1sum is that we don't have to extract the text.

        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):

            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)

        checker.checked_texts[key] = self.text_sha1

    def copy(self):

        other = InventoryFile(self.file_id, self.name, self.parent_id)

        other.executable = self.executable

        other.text_id = self.text_id

        other.text_sha1 = self.text_sha1

        other.text_size = self.text_size

        other.revision = self.revision

        return other

    def detect_changes(self, old_entry):

        """See InventoryEntry.detect_changes."""

        text_modified = (self.text_sha1 != old_entry.text_sha1)

        meta_modified = (self.executable != old_entry.executable)

        return text_modified, meta_modified

    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,

             output_to, reverse=False):

        """See InventoryEntry._diff."""

        from bzrlib.diff import DiffText

        from_file_id = self.file_id

        if to_entry:

            to_file_id = to_entry.file_id

        else:

            to_file_id = None

        if reverse:

            to_file_id, from_file_id = from_file_id, to_file_id

            tree, to_tree = to_tree, tree

            from_label, to_label = to_label, from_label

        differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',

                          text_diff)

        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)

    def has_text(self):

        """See InventoryEntry.has_text."""

        return True

    def __init__(self, file_id, name, parent_id):

        super(InventoryFile, self).__init__(file_id, name, parent_id)

        self.kind = 'file'

    def kind_character(self):

        """See InventoryEntry.kind_character."""

        return ''

    def _put_in_tar(self, item, tree):

        """See InventoryEntry._put_in_tar."""

        item.type = tarfile.REGTYPE

        fileobj = tree.get_file(self.file_id)

        item.size = self.text_size

        if tree.is_executable(self.file_id):

            item.mode = 0755

        else:

            item.mode = 0644

        return fileobj

    def _put_on_disk(self, fullpath, tree):

        """See InventoryEntry._put_on_disk."""

        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))

        if tree.is_executable(self.file_id):

            os.chmod(fullpath, 0755)

    def _read_tree_state(self, path, work_tree):

        """See InventoryEntry._read_tree_state."""

        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)

        # FIXME: 20050930 probe for the text size when getting sha1

        # in _read_tree_state

        self.executable = work_tree.is_executable(self.file_id, path=path)

    def __repr__(self):

        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s, revision=%s)"

                % (self.__class__.__name__,

                   self.file_id,

                   self.name,

                   self.parent_id,

                   self.text_sha1,

                   self.text_size,

                   self.revision))

    def _forget_tree_state(self):

        self.text_sha1 = None

    def _unchanged(self, previous_ie):

        """See InventoryEntry._unchanged."""

        compatible = super(InventoryFile, self)._unchanged(previous_ie)

        if self.text_sha1 != previous_ie.text_sha1:

            compatible = False

        else:

            # FIXME: 20050930 probe for the text size when getting sha1

            # in _read_tree_state

            self.text_size = previous_ie.text_size

        if self.executable != previous_ie.executable:

            compatible = False

        return compatible

class InventoryLink(InventoryEntry):

    """A file in an inventory."""

    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',

                 'text_id', 'parent_id', 'children', 'executable',

                 'revision', 'symlink_target', 'reference_revision']

    def _check(self, checker, rev_id, tree):

        """See InventoryEntry._check"""

        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:

            raise BzrCheckError('symlink {%s} has text in revision {%s}'

                    % (self.file_id, rev_id))

        if self.symlink_target is None:

            raise BzrCheckError('symlink {%s} has no target in revision {%s}'

                    % (self.file_id, rev_id))

    def copy(self):

        other = InventoryLink(self.file_id, self.name, self.parent_id)

        other.symlink_target = self.symlink_target

        other.revision = self.revision

        return other

    def detect_changes(self, old_entry):

        """See InventoryEntry.detect_changes."""

        # FIXME: which _modified field should we use ? RBC 20051003

        text_modified = (self.symlink_target != old_entry.symlink_target)

        if text_modified:

            mutter("    symlink target changed")

        meta_modified = False

        return text_modified, meta_modified

    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,

             output_to, reverse=False):

        """See InventoryEntry._diff."""

        from bzrlib.diff import DiffSymlink

        old_target = self.symlink_target

        if to_entry is not None:

            new_target = to_entry.symlink_target

        else:

            new_target = None

        if not reverse:

            old_tree = tree

            new_tree = to_tree

        else:

            old_tree = to_tree

            new_tree = tree

            new_target, old_target = old_target, new_target

        differ = DiffSymlink(old_tree, new_tree, output_to)

        return differ.diff_symlink(old_target, new_target)

    def __init__(self, file_id, name, parent_id):

        super(InventoryLink, self).__init__(file_id, name, parent_id)

        self.kind = 'symlink'

    def kind_character(self):

        """See InventoryEntry.kind_character."""

        return ''

    def _put_in_tar(self, item, tree):

        """See InventoryEntry._put_in_tar."""

        item.type = tarfile.SYMTYPE

        fileobj = None

        item.size = 0

        item.mode = 0755

        item.linkname = self.symlink_target