~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 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 bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import collections

import copy

import re

import tarfile

from bzrlib import (

    chk_map,

    errors,

    generate_ids,

    osutils,

    )

""")

from bzrlib import (

    lazy_regex,

    trace,

    )

from bzrlib.static_tuple import StaticTuple

from bzrlib.symbol_versioning import (

    deprecated_in,

    deprecated_method,

    )

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'

    >>> 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__ = ['file_id', 'revision', 'parent_id', 'name']

    # Attributes that all InventoryEntry instances are expected to have, but

    # that don't vary for all kinds of entry.  (e.g. symlink_target is only

    # relevant to InventoryLink, so there's no reason to make every

    # InventoryFile instance allocate space to hold a value for it.)

    # Attributes that only vary for files: executable, text_sha1, text_size,

    # text_id

    executable = False

    text_sha1 = None

    text_size = None

    text_id = None

    # Attributes that only vary for symlinks: symlink_target

    symlink_target = None

    # Attributes that only vary for tree-references: reference_revision

    reference_revision = None

    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 inv.has_id(self.file_id):

                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

    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):

        """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.file_id = file_id

        self.revision = None

        self.name = name

        self.parent_id = parent_id

    def kind_character(self):

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

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

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

    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):

        """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.

        """

        if self.parent_id is not None:

            if not inv.has_id(self.parent_id):

                raise errors.BzrCheckError(

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

                        self.parent_id, rev_id))

        checker._add_entry_to_text_key_references(inv, self)

        self._check(checker, rev_id)

    def _check(self, checker, rev_id):

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

        checker._report_items.append(

            '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 InventoryDirectory(InventoryEntry):

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

    __slots__ = ['children']

    kind = 'directory'

    def _check(self, checker, rev_id):

        """See InventoryEntry._check"""

        # In non rich root repositories we do not expect a file graph for the

        # root.

        if self.name == '' and not checker.rich_roots:

            return

        # Directories are stored as an empty file, but the file should exist

        # to provide a per-fileid log. The hash of every directory content is

        # "da..." below (the sha1sum of '').

        checker.add_pending_item(rev_id,

            ('texts', self.file_id, self.revision), 'text',

             'da39a3ee5e6b4b0d3255bfef95601890afd80709')

    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 = {}

    def kind_character(self):

        """See InventoryEntry.kind_character."""

        return '/'

class InventoryFile(InventoryEntry):

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

    __slots__ = ['text_sha1', 'text_size', 'text_id', 'executable']

    kind = 'file'

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

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

        self.text_sha1 = None

        self.text_size = None

        self.text_id = None

        self.executable = False

    def _check(self, checker, tree_revision_id):

        """See InventoryEntry._check"""

        # TODO: check size too.

        checker.add_pending_item(tree_revision_id,

            ('texts', self.file_id, self.revision), 'text',

             self.text_sha1)

        if self.text_size is None:

            checker._report_items.append(

                'fileid {%s} in {%s} has None for text_size' % (self.file_id,

                tree_revision_id))

    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 kind_character(self):

        """See InventoryEntry.kind_character."""

        return ''

    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__ = ['symlink_target']

    kind = 'symlink'

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

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

        self.symlink_target = None

    def _check(self, checker, tree_revision_id):

        """See InventoryEntry._check"""

        if self.symlink_target is None:

            checker._report_items.append(

                'symlink {%s} has no target in revision {%s}'

                    % (self.file_id, tree_revision_id))

        # Symlinks are stored as ''

        checker.add_pending_item(tree_revision_id,

            ('texts', self.file_id, self.revision), 'text',

             'da39a3ee5e6b4b0d3255bfef95601890afd80709')

    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:

            trace.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 kind_character(self):

        """See InventoryEntry.kind_character."""

        return ''

    def _read_tree_state(self, path, work_tree):

        """See InventoryEntry._read_tree_state."""

        self.symlink_target = work_tree.get_symlink_target(self.file_id)

    def _forget_tree_state(self):

        self.symlink_target = None

    def _unchanged(self, previous_ie):

        """See InventoryEntry._unchanged."""

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

        if self.symlink_target != previous_ie.symlink_target:

            compatible = False

        return compatible

class TreeReference(InventoryEntry):

    __slots__ = ['reference_revision']

    kind = 'tree-reference'

    def __init__(self, file_id, name, parent_id, revision=None,

                 reference_revision=None):

        InventoryEntry.__init__(self, file_id, name, parent_id)

        self.revision = revision

        self.reference_revision = reference_revision

    def copy(self):

        return TreeReference(self.file_id, self.name, self.parent_id,

                             self.revision, self.reference_revision)

    def _read_tree_state(self, path, work_tree):

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

        """

        self.reference_revision = work_tree.get_reference_revision(

            self.file_id, path)

    def _forget_tree_state(self):

        self.reference_revision = None

    def _unchanged(self, previous_ie):

        """See InventoryEntry._unchanged."""

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

        if self.reference_revision != previous_ie.reference_revision:

            compatible = False

        return compatible

class CommonInventory(object):

    """Basic inventory logic, defined in terms of primitives like has_id.

    An inventory is the metadata about the contents of a tree.

    This is broadly a map from file_id to entries such as directories, files,

    symlinks and tree references. Each entry maintains its own metadata like

    SHA1 and length for files, or children for a directory.

    Entries can be looked up either by path or by file_id.

    InventoryEntry objects must not be modified after they are

    inserted, other than through the Inventory API.

    """

    @deprecated_method(deprecated_in((2, 4, 0)))

    def __contains__(self, file_id):

        """True if this entry contains a file with given id.

        >>> inv = Inventory()

        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))

        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)

        >>> inv.has_id('123')

        True

        >>> inv.has_id('456')

        False

        Note that this method along with __iter__ are not encouraged for use as

        they are less clear than specific query methods - they may be rmeoved

        in the future.

        """

        return self.has_id(file_id)

    def has_filename(self, filename):

        return bool(self.path2id(filename))

    def id2path(self, file_id):

        """Return as a string the path to file_id.

        >>> i = Inventory()

        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))

        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))

        >>> print i.id2path('foo-id')

        src/foo.c

        :raises NoSuchId: If file_id is not present in the inventory.

        """

        # get all names, skipping root

        return '/'.join(reversed(

            [parent.name for parent in

             self._iter_file_id_parents(file_id)][:-1]))

    def iter_entries(self, from_dir=None, recursive=True):

        """Return (path, entry) pairs, in order by name.

        :param from_dir: if None, start from the root,

          otherwise start from this directory (either file-id or entry)

        :param recursive: recurse into directories or not

        """

        if from_dir is None:

            if self.root is None:

                return

            from_dir = self.root

            yield '', self.root

        elif isinstance(from_dir, basestring):

            from_dir = self[from_dir]

        # unrolling the recursive called changed the time from

        # 440ms/663ms (inline/total) to 116ms/116ms

        children = from_dir.children.items()

        children.sort()

        if not recursive:

            for name, ie in children:

                yield name, ie

            return