/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

from collections import deque

import errno

from io import BytesIO

import os

from dulwich import __version__ as dulwich_version

from dulwich.config import (

    parse_submodules,

    ConfigFile as GitConfigFile,

    )

from dulwich.diff_tree import tree_changes, RenameDetector

from dulwich.errors import NotTreeError

from dulwich.index import (

    blob_from_path_and_stat,

    cleanup_mode,

    commit_tree,

    index_entry_from_stat,

    Index,

    )

from dulwich.object_store import (

    tree_lookup_path,

    OverlayObjectStore,

    )

from dulwich.objects import (

    Blob,

    Tree,

    ZERO_SHA,

    S_IFGITLINK,

    S_ISGITLINK,

    )

import stat

import posixpath

from .. import (

    controldir as _mod_controldir,

    delta,

    errors,

    mutabletree,

    osutils,

    revisiontree,

    trace,

    tree as _mod_tree,

    workingtree,

    )

from ..revision import (

    CURRENT_REVISION,

    NULL_REVISION,

    )

from ..sixish import (

    text_type,

    viewitems,

    )

from .mapping import (

    mode_is_executable,

    mode_kind,

    default_mapping,

    )

from .transportgit import (

    TransportObjectStore,

    TransportRepo,

    )

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)

class GitTreeSubmodule(_mod_tree.TreeReference):

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

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

        self.file_id = file_id

        self.name = name

        self.parent_id = parent_id

        self.reference_revision = reference_revision

    @property

    def executable(self):

        return False

    @property

    def kind(self):

        return 'tree-reference'

    def __repr__(self):

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

                "reference_revision=%r)") % (

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

            self.reference_revision)

    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.reference_revision == other.reference_revision)

    def copy(self):

        return self.__class__(

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

            self.reference_revision)

entry_factory = {

    'directory': GitTreeDirectory,

    'file': GitTreeFile,

    'symlink': GitTreeSymlink,

    'tree-reference': GitTreeSubmodule,

    }

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._submodules = None

        self.store = repository._git.object_store

        if not isinstance(revision_id, bytes):

            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

        else:

            try:

                commit = self.store[self.commit_id]

            except KeyError:

                raise errors.NoSuchRevision(repository, revision_id)

            self.tree = commit.tree

    def _submodule_info(self):

        if self._submodules is None:

            try:

                with self.get_file('.gitmodules') as f:

                    config = GitConfigFile.from_file(f)

                    self._submodules = {

                        path: (url, section)

                        for path, url, section in parse_submodules(config)}

            except errors.NoSuchFile:

                self._submodules = {}

        return self._submodules

    def _get_submodule_repository(self, relpath):

        if not isinstance(relpath, bytes):

            raise TypeError(relpath)

        try:

            info = self._submodule_info()[relpath]

        except KeyError:

            nested_repo_transport = self._repository.controldir.user_transport.clone(

                relpath.decode('utf-8'))

        else:

            nested_repo_transport = self._repository.controldir.control_transport.clone(

                posixpath.join('modules', info[1].decode('utf-8')))

        nested_controldir = _mod_controldir.ControlDir.open_from_transport(

            nested_repo_transport)

        return nested_controldir.find_repository()

    def _get_submodule_store(self, relpath):

        return self._get_submodule_repository(relpath)._git.object_store

    def get_nested_tree(self, path):

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

        nested_repo = self._get_submodule_repository(encoded_path)

        ref_rev = self.get_reference_revision(path)

        return nested_repo.revision_tree(ref_rev)

    def supports_rename_tracking(self):

        return False

    def get_file_revision(self, path):

        change_scanner = self._repository._file_change_scanner

        if self.commit_id == ZERO_SHA:

            return NULL_REVISION

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

        try:

            revid = self.get_file_revision(path)

        except KeyError:

            raise errors.NoSuchFile(path)

        try:

            rev = self._repository.get_revision(revid)

        except errors.NoSuchRevision:

            raise _mod_tree.FileTimestampUnavailable(path)

        return rev.timestamp

    def id2path(self, file_id, recurse='down'):

        try:

            path = self.mapping.parse_file_id(file_id)

        except ValueError:

            raise errors.NoSuchId(self, file_id)

        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

        if not self.is_versioned(path):

            return None

        return self.mapping.generate_file_id(osutils.safe_unicode(path))

    def all_file_ids(self):

        raise errors.UnsupportedOperation(self.all_file_ids, self)

    def all_versioned_paths(self):

        ret = {u''}

        todo = [(self.store, b'', 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)

                ret.add(subpath.decode('utf-8'))

                if stat.S_ISDIR(mode):

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

        return ret

    def _lookup_path(self, path):

        if self.tree is None:

            raise errors.NoSuchFile(path)

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

        parts = encoded_path.split(b'/')

        hexsha = self.tree

        store = self.store

        mode = None

        for i, p in enumerate(parts):

            if not p:

                continue

            obj = store[hexsha]

            if not isinstance(obj, Tree):

                raise NotTreeError(hexsha)

            try:

                mode, hexsha = obj[p]

            except KeyError:

                raise errors.NoSuchFile(path)

            if S_ISGITLINK(mode) and i != len(parts) - 1:

                store = self._get_submodule_store(b'/'.join(parts[:i + 1]))

                hexsha = store[hexsha].tree

        return (store, mode, hexsha)

    def is_executable(self, path):

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

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

        if self._submodules is None:

            try:

                with self.get_file('.gitmodules') as f:

                    config = GitConfigFile.from_file(f)

                    self._submodules = {

                        path: (url, section)

                        for path, url, section in parse_submodules(config)}

            except errors.NoSuchFile:

                self._submodules = {}

        return self._submodules

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

                   recurse_nested=False):

        if self.tree is None:

            return

        if from_dir is None or from_dir == '.':

            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)

            parent_id = self.mapping.generate_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 include_root:

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

        todo = []

        if root_ie.kind == 'directory':

            todo.append((store, from_dir.encode("utf-8"),

                         b"", hexsha, root_ie.file_id))

        while todo:

            (store, path, relpath, 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)

                child_relpath = posixpath.join(relpath, name)

                if S_ISGITLINK(mode) and recurse_nested:

                    mode = stat.S_IFDIR

                    store = self._get_submodule_store(child_relpath)

                    hexsha = store[hexsha].tree

                if stat.S_ISDIR(mode):

                    ie = self._get_dir_ie(child_path, parent_id)

                    if recursive:

                        todo.append(

                            (store, child_path, child_relpath, hexsha,

                             ie.file_id))

                else:

                    ie = self._get_file_ie(

                        store, child_path, name, mode, hexsha, parent_id)

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

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

        if not isinstance(path, bytes):

            raise TypeError(path)

        if not isinstance(name, bytes):

            raise TypeError(name)

        kind = mode_kind(mode)

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

        name = name.decode("utf-8")

        file_id = self.mapping.generate_file_id(path)

        ie = entry_factory[kind](file_id, name, 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):

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

        file_id = self.mapping.generate_file_id(path)

        return GitTreeDirectory(file_id, posixpath.basename(path), parent_id)

    def iter_child_entries(self, path):

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

        if mode is not None and 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,

                            recurse_nested=False):

        if self.tree is None:

            return

        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 = deque([(self.store, b"", self.tree, self.path2id(''))])

        if specific_files is None or u"" in specific_files:

            yield u"", self._get_dir_ie(b"", None)

        while todo:

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

            tree = store[tree_sha]

            extradirs = []

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

                if self.mapping.is_special_file(name):

                    continue

                child_path = posixpath.join(path, name)

                child_path_decoded = child_path.decode('utf-8')

                if recurse_nested and S_ISGITLINK(mode):

                    mode = stat.S_IFDIR

                    store = self._get_submodule_store(child_path)

                    hexsha = store[hexsha].tree

                if stat.S_ISDIR(mode):

                    if (specific_files is None or

                            any([p for p in specific_files if p.startswith(

                                child_path)])):

                        extradirs.append(

                            (store, child_path, hexsha,

                             self.path2id(child_path_decoded)))

                if specific_files is None or child_path in specific_files:

                    if stat.S_ISDIR(mode):

                        yield (child_path_decoded,

                               self._get_dir_ie(child_path, parent_id))

                    else:

                        yield (child_path_decoded,

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

                                                 hexsha, parent_id))

            todo.extendleft(reversed(extradirs))

    def iter_references(self):

        if self.supports_tree_reference():

            for path, entry in self.iter_entries_by_dir():

                if entry.kind == 'tree-reference':

                    yield path