/brz/remove-bazaar

# Copyright (C) 2009-2018 Jelmer Vernooij <jelmer@jelmer.uk>

#

# 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

"""Git Trees."""

from __future__ import absolute_import

import errno

from io import BytesIO

import os

from dulwich.index import (

    index_entry_from_stat,

    )

from dulwich.object_store import (

    tree_lookup_path,

    OverlayObjectStore,

    )

from dulwich.objects import (

    Blob,

    Tree,

    ZERO_SHA,

    )

import stat

import posixpath

from ... import (

    delta,

    errors,

    lock,

    mutabletree,

    osutils,

    revisiontree,

    trace,

    tree as _mod_tree,

    workingtree,

    )

from ...revision import NULL_REVISION

from .mapping import (

    mode_is_executable,

    mode_kind,

    GitFileIdMap,

    default_mapping,

    )

class GitTreeDirectory(_mod_tree.TreeDirectory):

    __slots__ = ['file_id', 'name', 'parent_id', 'children']

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

        self.file_id = file_id

        self.name = name

        self.parent_id = parent_id

        # TODO(jelmer)

        self.children = {}

    @property

    def kind(self):

        return 'directory'

    @property

    def executable(self):

        return False

    def copy(self):

        return self.__class__(

            self.file_id, self.name, self.parent_id)

    def __repr__(self):

        return "%s(file_id=%r, name=%r, parent_id=%r)" % (

            self.__class__.__name__, self.file_id, self.name,

            self.parent_id)

    def __eq__(self, other):

        return (self.kind == other.kind and

                self.file_id == other.file_id and

                self.name == other.name and

                self.parent_id == other.parent_id)

class GitTreeFile(_mod_tree.TreeFile):

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

                 'executable']

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

                 text_sha1=None, executable=None):

        self.file_id = file_id

        self.name = name

        self.parent_id = parent_id

        self.text_size = text_size

        self.text_sha1 = text_sha1

        self.executable = executable

    @property

    def kind(self):

        return 'file'

    def __eq__(self, other):

        return (self.kind == other.kind and

                self.file_id == other.file_id and

                self.name == other.name and

                self.parent_id == other.parent_id and

                self.text_sha1 == other.text_sha1 and

                self.text_size == other.text_size and

                self.executable == other.executable)

    def __repr__(self):

        return "%s(file_id=%r, name=%r, parent_id=%r, text_size=%r, text_sha1=%r, executable=%r)" % (

            type(self).__name__, self.file_id, self.name, self.parent_id,

            self.text_size, self.text_sha1, self.executable)

    def copy(self):

        ret = self.__class__(

                self.file_id, self.name, self.parent_id)

        ret.text_sha1 = self.text_sha1

        ret.text_size = self.text_size

        ret.executable = self.executable

        return ret

class GitTreeSymlink(_mod_tree.TreeLink):

    __slots__ = ['file_id', 'name', 'parent_id', 'symlink_target']

    def __init__(self, file_id, name, parent_id,

                 symlink_target=None):

        self.file_id = file_id

        self.name = name

        self.parent_id = parent_id

        self.symlink_target = symlink_target

    @property

    def kind(self):

        return 'symlink'

    @property

    def executable(self):

        return False

    @property

    def text_size(self):

        return None

    def __repr__(self):

        return "%s(file_id=%r, name=%r, parent_id=%r, symlink_target=%r)" % (

            type(self).__name__, self.file_id, self.name, self.parent_id,

            self.symlink_target)

    def __eq__(self, other):

        return (self.kind == other.kind and

                self.file_id == other.file_id and

                self.name == other.name and

                self.parent_id == other.parent_id and

                self.symlink_target == other.symlink_target)

    def copy(self):

        return self.__class__(

                self.file_id, self.name, self.parent_id,

                self.symlink_target)

entry_factory = {

    'directory': GitTreeDirectory,

    'file': GitTreeFile,

    'symlink': GitTreeSymlink,

    }

def ensure_normalized_path(path):

    """Check whether path is normalized.

    :raises InvalidNormalization: When path is not normalized, and cannot be

        accessed on this platform by the normalized path.

    :return: The NFC normalised version of path.

    """

    norm_path, can_access = osutils.normalized_filename(path)

    if norm_path != path:

        if can_access:

            return norm_path

        else:

            raise errors.InvalidNormalization(path)

    return path

class GitRevisionTree(revisiontree.RevisionTree):

    """Revision tree implementation based on Git objects."""

    def __init__(self, repository, revision_id):

        self._revision_id = revision_id

        self._repository = repository

        self.store = repository._git.object_store

        if type(revision_id) is not str:

            raise TypeError(revision_id)

        self.commit_id, self.mapping = repository.lookup_bzr_revision_id(revision_id)

        if revision_id == NULL_REVISION:

            self.tree = None

            self.mapping = default_mapping

            self._fileid_map = GitFileIdMap(

                {},

                default_mapping)

        else:

            try:

                commit = self.store[self.commit_id]

            except KeyError, r:

                raise errors.NoSuchRevision(repository, revision_id)

            self.tree = commit.tree

            self._fileid_map = self.mapping.get_fileid_map(self.store.__getitem__, self.tree)

    def supports_rename_tracking(self):

        return False

    def get_file_revision(self, path, file_id=None):

        change_scanner = self._repository._file_change_scanner

        if self.commit_id == ZERO_SHA:

            return NULL_REVISION

        (path, commit_id) = change_scanner.find_last_change_revision(

            path.encode('utf-8'), self.commit_id)

        return self._repository.lookup_foreign_revision_id(commit_id, self.mapping)

    def get_file_mtime(self, path, file_id=None):

        revid = self.get_file_revision(path, file_id)

        try:

            rev = self._repository.get_revision(revid)

        except errors.NoSuchRevision:

            raise errors.FileTimestampUnavailable(path)

        return rev.timestamp

    def id2path(self, file_id):

        try:

            path = self._fileid_map.lookup_path(file_id)

        except ValueError:

            raise errors.NoSuchId(self, file_id)

        path = path.decode('utf-8')

        if self.is_versioned(path):

            return path

        raise errors.NoSuchId(self, file_id)

    def is_versioned(self, path):

        return self.has_filename(path)

    def path2id(self, path):

        if self.mapping.is_special_file(path):

            return None

        return self._fileid_map.lookup_file_id(path.encode('utf-8'))

    def all_file_ids(self):

        return set(self._fileid_map.all_file_ids())

    def all_versioned_paths(self):

        ret = set()

        todo = set([(store, '', self.tree)])

        while todo:

            (store, path, tree_id) = todo.pop()

            if tree_id is None:

                continue

            tree = store[tree_id]

            for name, mode, hexsha in tree.items():

                subpath = posixpath.join(path, name)

                if stat.S_ISDIR(mode):

                    todo.add((store, subpath, hexsha))

                else:

                    ret.add(subpath)

        return ret

    def get_root_id(self):

        if self.tree is None:

            return None

        return self.path2id("")

    def has_or_had_id(self, file_id):

        try:

            path = self.id2path(file_id)

        except errors.NoSuchId:

            return False

        return True

    def has_id(self, file_id):

        try:

            path = self.id2path(file_id)

        except errors.NoSuchId:

            return False

        return self.has_filename(path)

    def _lookup_path(self, path):

        if self.tree is None:

            raise errors.NoSuchFile(path)

        try:

            (mode, hexsha) = tree_lookup_path(self.store.__getitem__, self.tree,

                path.encode('utf-8'))

        except KeyError:

            raise errors.NoSuchFile(self, path)

        else:

            return (self.store, mode, hexsha)

    def is_executable(self, path, file_id=None):

        (store, mode, hexsha) = self._lookup_path(path)

        if mode is None:

            # the tree root is a directory

            return False

        return mode_is_executable(mode)

    def kind(self, path, file_id=None):

        (store, mode, hexsha) = self._lookup_path(path)

        if mode is None:

            # the tree root is a directory

            return "directory"

        return mode_kind(mode)

    def has_filename(self, path):

        try:

            self._lookup_path(path)

        except errors.NoSuchFile:

            return False

        else:

            return True

    def list_files(self, include_root=False, from_dir=None, recursive=True):

        if self.tree is None:

            return

        if from_dir is None:

            from_dir = u""

        (store, mode, hexsha) = self._lookup_path(from_dir)

        if mode is None: # Root

            root_ie = self._get_dir_ie(b"", None)

        else:

            parent_path = posixpath.dirname(from_dir.encode("utf-8"))

            parent_id = self._fileid_map.lookup_file_id(parent_path)

            if mode_kind(mode) == 'directory':

                root_ie = self._get_dir_ie(from_dir.encode("utf-8"), parent_id)

            else:

                root_ie = self._get_file_ie(store, from_dir.encode("utf-8"),

                    posixpath.basename(from_dir), mode, hexsha)

        if from_dir != "" or include_root:

            yield (from_dir, "V", root_ie.kind, root_ie.file_id, root_ie)

        todo = set()

        if root_ie.kind == 'directory':

            todo.add((store, from_dir.encode("utf-8"), hexsha, root_ie.file_id))

        while todo:

            (store, path, hexsha, parent_id) = todo.pop()

            tree = store[hexsha]

            for name, mode, hexsha in tree.iteritems():

                if self.mapping.is_special_file(name):

                    continue

                child_path = posixpath.join(path, name)

                if stat.S_ISDIR(mode):

                    ie = self._get_dir_ie(child_path, parent_id)

                    if recursive:

                        todo.add((store, child_path, hexsha, ie.file_id))

                else:

                    ie = self._get_file_ie(store, child_path, name, mode, hexsha, parent_id)

                yield child_path.decode('utf-8'), "V", ie.kind, ie.file_id, ie

    def _get_file_ie(self, store, path, name, mode, hexsha, parent_id):

        if type(path) is not bytes:

            raise TypeError(path)

        if type(name) is not bytes:

            raise TypeError(name)

        kind = mode_kind(mode)

        file_id = self._fileid_map.lookup_file_id(path)

        ie = entry_factory[kind](file_id, name.decode("utf-8"), parent_id)

        if kind == 'symlink':

            ie.symlink_target = store[hexsha].data.decode('utf-8')

        elif kind == 'tree-reference':

            ie.reference_revision = self.mapping.revision_id_foreign_to_bzr(hexsha)

        else:

            data = store[hexsha].data

            ie.text_sha1 = osutils.sha_string(data)

            ie.text_size = len(data)

            ie.executable = mode_is_executable(mode)

        return ie

    def _get_dir_ie(self, path, parent_id):

        file_id = self._fileid_map.lookup_file_id(path)

        return GitTreeDirectory(file_id,

            posixpath.basename(path).decode("utf-8"), parent_id)

    def iter_child_entries(self, path, file_id=None):

        (store, mode, tree_sha) = self._lookup_path(path)

        if not stat.S_ISDIR(mode):

            return

        encoded_path = path.encode('utf-8')

        file_id = self.path2id(path)

        tree = store[tree_sha]

        for name, mode, hexsha in tree.iteritems():

            if self.mapping.is_special_file(name):

                continue

            child_path = posixpath.join(encoded_path, name)

            if stat.S_ISDIR(mode):

                yield self._get_dir_ie(child_path, file_id)

            else:

                yield self._get_file_ie(store, child_path, name, mode, hexsha,

                                        file_id)

    def iter_entries_by_dir(self, specific_files=None, yield_parents=False):

        if self.tree is None:

            return

        if yield_parents:

            # TODO(jelmer): Support yield parents

            raise NotImplementedError

        if specific_files is not None:

            if specific_files in ([""], []):

                specific_files = None

            else:

                specific_files = set([p.encode('utf-8') for p in specific_files])

        todo = set([(self.store, "", self.tree, None)])

        while todo:

            store, path, tree_sha, parent_id = todo.pop()

            ie = self._get_dir_ie(path, parent_id)

            if specific_files is None or path in specific_files:

                yield path.decode("utf-8"), ie

            tree = store[tree_sha]

            for name, mode, hexsha in tree.iteritems():

                if self.mapping.is_special_file(name):

                    continue

                child_path = posixpath.join(path, name)

                if stat.S_ISDIR(mode):

                    if (specific_files is None or

                        any(filter(lambda p: p.startswith(child_path), specific_files))):

                        todo.add((store, child_path, hexsha, ie.file_id))

                elif specific_files is None or child_path in specific_files:

                    yield (child_path.decode("utf-8"),

                            self._get_file_ie(store, child_path, name, mode, hexsha,

                           ie.file_id))

    def get_revision_id(self):

        """See RevisionTree.get_revision_id."""

        return self._revision_id

    def get_file_sha1(self, path, file_id=None, stat_value=None):

        if self.tree is None:

            raise errors.NoSuchFile(path)

        return osutils.sha_string(self.get_file_text(path, file_id))

    def get_file_verifier(self, path, file_id=None, stat_value=None):

        (store, mode, hexsha) = self._lookup_path(path)

        return ("GIT", hexsha)

    def get_file_text(self, path, file_id=None):

        """See RevisionTree.get_file_text."""

        (store, mode, hexsha) = self._lookup_path(path)

        if stat.S_ISREG(mode):

            return store[hexsha].data

        else:

            return b""

    def get_symlink_target(self, path, file_id=None):

        """See RevisionTree.get_symlink_target."""

        (store, mode, hexsha) = self._lookup_path(path)

        if stat.S_ISLNK(mode):

            return store[hexsha].data.decode('utf-8')

        else:

            return None

    def _comparison_data(self, entry, path):

        if entry is None:

            return None, False, None

        return entry.kind, entry.executable, None

    def path_content_summary(self, path):

        """See Tree.path_content_summary."""

        try:

            (store, mode, hexsha) = self._lookup_path(path)

        except errors.NoSuchFile:

            return ('missing', None, None, None)

        kind = mode_kind(mode)

        if kind == 'file':

            executable = mode_is_executable(mode)

            contents = store[hexsha].data

            return (kind, len(contents), executable, osutils.sha_string(contents))

        elif kind == 'symlink':

            return (kind, None, None, store[hexsha].data)

        else:

            return (kind, None, None, None)

    def find_related_paths_across_trees(self, paths, trees=[],

            require_versioned=True):

        if paths is None:

            return None

        if require_versioned:

            trees = [self] + (trees if trees is not None else [])

            unversioned = set()

            for p in paths:

                for t in trees:

                    if t.is_versioned(p):

                        break

                else:

                    unversioned.add(p)

            if unversioned:

                raise errors.PathsNotVersionedError(unversioned)

        return filter(self.is_versioned, paths)

    def _iter_tree_contents(self, include_trees=False):

        if self.tree is None:

            return iter([])

        return self.store.iter_tree_contents(

                self.tree, include_trees=include_trees)

def tree_delta_from_git_changes(changes, mapping,

        (old_fileid_map, new_fileid_map), specific_files=None,

        require_versioned=False, include_root=False,

        target_extras=None):

    """Create a TreeDelta from two git trees.

    source and target are iterators over tuples with:

        (filename, sha, mode)

    """

    if target_extras is None:

        target_extras = set()

    ret = delta.TreeDelta()

    for (oldpath, newpath), (oldmode, newmode), (oldsha, newsha) in changes:

        if newpath == u'' and not include_root:

            continue

        if not (specific_files is None or

                (oldpath is not None and osutils.is_inside_or_parent_of_any(specific_files, oldpath)) or

                (newpath is not None and osutils.is_inside_or_parent_of_any(specific_files, newpath))):

            continue

        if mapping.is_special_file(oldpath):

            oldpath = None

        if mapping.is_special_file(newpath):

            newpath = None

        if oldpath is None and newpath is None:

            continue

        if oldpath is None:

            if newpath in target_extras:

                ret.unversioned.append(

                    (osutils.normalized_filename(newpath)[0], None, mode_kind(newmode)))

            else:

                file_id = new_fileid_map.lookup_file_id(newpath)

                ret.added.append((newpath.decode('utf-8'), file_id, mode_kind(newmode)))

        elif newpath is None:

            file_id = old_fileid_map.lookup_file_id(oldpath)

            ret.removed.append((oldpath.decode('utf-8'), file_id, mode_kind(oldmode)))

        elif oldpath != newpath:

            file_id = old_fileid_map.lookup_file_id(oldpath)

            ret.renamed.append(

                (oldpath.decode('utf-8'), newpath.decode('utf-8'), file_id,

                mode_kind(newmode), (oldsha != newsha),

                (oldmode != newmode)))

        elif mode_kind(oldmode) != mode_kind(newmode):

            file_id = new_fileid_map.lookup_file_id(newpath)

            ret.kind_changed.append(

                (newpath.decode('utf-8'), file_id, mode_kind(oldmode),

                mode_kind(newmode)))

        elif oldsha != newsha or oldmode != newmode:

            if stat.S_ISDIR(oldmode) and stat.S_ISDIR(newmode):

                continue

            file_id = new_fileid_map.lookup_file_id(newpath)

            ret.modified.append(