# -*- coding: utf-8 -*-

"""

    vcs.backends.base

    ~~~~~~~~~~~~~~~~~

    Base for all available scm backends

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

from itertools import chain

from rhodecode.lib.vcs.utils import author_name, author_email

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils.helpers import get_dict_for_attrs

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, \

    NodeAlreadyAddedError, NodeAlreadyChangedError, NodeAlreadyExistsError, \

    NodeAlreadyRemovedError, NodeDoesNotExistError, NodeNotChangedError, \

    RepositoryError

class BaseRepository(object):

    """

    Base Repository for final backends

    **Attributes**

        ``DEFAULT_BRANCH_NAME``

            name of default branch (i.e. "trunk" for svn, "master" for git etc.

        ``scm``

            alias of scm, i.e. *git* or *hg*

        ``repo``

            object from external api

        ``revisions``

            list of all available revisions' ids, in ascending order

        ``changesets``

            storage dict caching returned changesets

        ``path``

            absolute path to the repository

        ``branches``

            branches as list of changesets

        ``tags``

            tags as list of changesets

    """

    scm = None

    DEFAULT_BRANCH_NAME = None

    EMPTY_CHANGESET = '0' * 40

    def __init__(self, repo_path, create=False, **kwargs):

        """

        Initializes repository. Raises RepositoryError if repository could

        not be find at the given ``repo_path`` or directory at ``repo_path``

        exists and ``create`` is set to True.

        :param repo_path: local path of the repository

        :param create=False: if set to True, would try to craete repository.

        :param src_url=None: if set, should be proper url from which repository

          would be cloned; requires ``create`` parameter to be set to True -

          raises RepositoryError if src_url is set and create evaluates to

          False

        """

        raise NotImplementedError

    def __str__(self):

        return '<%s at %s>' % (self.__class__.__name__, self.path)

    def __repr__(self):

        return self.__str__()

    def __len__(self):

        return self.count()

    @LazyProperty

    def alias(self):

        for k, v in settings.BACKENDS.items():

            if v.split('.')[-1] == str(self.__class__.__name__):

                return k

    @LazyProperty

    def name(self):

        raise NotImplementedError

    @LazyProperty

    def owner(self):

        raise NotImplementedError

    @LazyProperty

    def description(self):

        raise NotImplementedError

    @LazyProperty

    def size(self):

        """

        Returns combined size in bytes for all repository files

        """

        size = 0

        try:

            tip = self.get_changeset()

            for topnode, dirs, files in tip.walk('/'):

                for f in files:

                    size += tip.get_file_size(f.path)

                for dir in dirs:

                    for f in files:

                        size += tip.get_file_size(f.path)

        except RepositoryError, e:

            pass

            if len(parents) == 0:

                try:

                    parents = [self.repository.get_changeset(), None]

                except EmptyRepositoryError:

                    parents = [None, None]

            elif len(parents) == 1:

                parents += [None]

            self.parents = parents

        # Local parents, only if not None

        parents = [p for p in self.parents if p]

        # Check nodes marked as added

        for p in parents:

            for node in self.added:

                try:

                    p.get_node(node.path)

                except NodeDoesNotExistError:

                    pass

                else:

                    raise NodeAlreadyExistsError("Node at %s already exists "

                        "at %s" % (node.path, p))

        # Check nodes marked as changed

        missing = set(self.changed)

        not_changed = set(self.changed)

        if self.changed and not parents:

            raise NodeDoesNotExistError(str(self.changed[0].path))

        for p in parents:

            for node in self.changed:

                try:

                    old = p.get_node(node.path)

                    missing.remove(node)

                    if old.content != node.content:

                        not_changed.remove(node)

                except NodeDoesNotExistError:

                    pass

        if self.changed and missing:

            raise NodeDoesNotExistError("Node at %s is missing "

                "(parents: %s)" % (node.path, parents))

        if self.changed and not_changed:

            raise NodeNotChangedError("Node at %s wasn't actually changed "

                "since parents' changesets: %s" % (not_changed.pop().path,

                    parents)

            )

        # Check nodes marked as removed

        if self.removed and not parents:

            raise NodeDoesNotExistError("Cannot remove node at %s as there "

                "were no parents specified" % self.removed[0].path)

        really_removed = set()

        for p in parents:

            for node in self.removed:

                try:

                    p.get_node(node.path)

                    really_removed.add(node)

                except ChangesetError:

                    pass

        not_removed = set(self.removed) - really_removed

        if not_removed:

            raise NodeDoesNotExistError("Cannot remove node at %s from "

                "following parents: %s" % (not_removed[0], parents))

    def commit(self, message, author, parents=None, branch=None, date=None,

            **kwargs):

        """

        Performs in-memory commit (doesn't check workdir in any way) and

        returns newly created ``Changeset``. Updates repository's

        ``revisions``.

        .. note::

            While overriding this method each backend's should call

            ``self.check_integrity(parents)`` in the first place.

        :param message: message of the commit

        :param author: full username, i.e. "Joe Doe <joe.doe@example.com>"

        :param parents: single parent or sequence of parents from which commit

          would be derieved

        :param date: ``datetime.datetime`` instance. Defaults to

          ``datetime.datetime.now()``.

        :param branch: branch name, as string. If none given, default backend's

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        raise NotImplementedError

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset. It's possible to pass hash when creating

    an EmptyChangeset

    """

    def __init__(self, cs='0' * 40, repo=None, requested_revision=None,

        self._empty_cs = cs

        self.revision = revision

        self.message = message

        self.author = author

        self.repository = repo

        self.requested_revision = requested_revision

        self.alias = alias

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifying this changeset, useful for web

        representation.

        """

        return self._empty_cs

    @LazyProperty

    def branch(self):

        from rhodecode.lib.vcs.backends import get_backend

        return get_backend(self.alias).DEFAULT_BRANCH_NAME

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

    def get_file_changeset(self, path):

        return self

    def get_file_content(self, path):

        return u''

    def get_file_size(self, path):

        return 0

import re

from itertools import chain

from dulwich import objects

from subprocess import Popen, PIPE

import rhodecode

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import ChangesetError

from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import ImproperArchiveTypeError

from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyChangeset

from rhodecode.lib.vcs.nodes import FileNode, DirNode, NodeKind, RootNode, \

    RemovedFileNode, SubModuleNode, ChangedFileNodesGenerator,\

    AddedFileNodesGenerator, RemovedFileNodesGenerator

from rhodecode.lib.vcs.utils import safe_unicode

from rhodecode.lib.vcs.utils import date_fromtimestamp

from rhodecode.lib.vcs.utils.lazy import LazyProperty

class GitChangeset(BaseChangeset):

    """

    Represents state of the repository at single revision.

    """

    def __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        try:

            commit = self.repository._repo.get_object(revision)

            if isinstance(commit, objects.Tag):

                revision = commit.object[1]

                commit = self.repository._repo.get_object(commit.object[1])

        except KeyError:

            raise RepositoryError("Cannot get object with id %s" % revision)

        self.raw_id = revision

        self.id = self.raw_id

        self.short_id = self.raw_id[:12]

        self._commit = commit

        self._tree_id = commit.tree

        self._committer_property = 'committer'

        self._author_property = 'author'

        self._date_property = 'commit_time'

        self._date_tz_property = 'commit_timezone'

        self.revision = repository.revisions.index(revision)

        self.message = safe_unicode(commit.message)

        self.nodes = {}

        self._paths = {}

    @LazyProperty

    def committer(self):

        return safe_unicode(getattr(self._commit, self._committer_property))

    @LazyProperty

    def author(self):

        return safe_unicode(getattr(self._commit, self._author_property))

    @LazyProperty

    def date(self):

        return date_fromtimestamp(getattr(self._commit, self._date_property),

                                  getattr(self._commit, self._date_tz_property))

    @LazyProperty

    def _timestamp(self):

        return getattr(self._commit, self._date_property)

    @LazyProperty

    def status(self):

        """

        Returns modified, added, removed, deleted files for current changeset

        """

        return self.changed, self.added, self.removed

    @LazyProperty

    def tags(self):

        _tags = []

        for tname, tsha in self.repository.tags.iteritems():

            if tsha == self.raw_id:

                _tags.append(tname)

        return _tags

    @LazyProperty

    def branch(self):

        heads = self.repository._heads(reverse=False)

        ref = heads.get(self.raw_id)

        if ref:

            return safe_unicode(ref)

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed.

        """

        if path.endswith('/'):

            path = path.rstrip('/')

        return path

    def _get_id_for_path(self, path):

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if not path in self._paths:

            path = path.strip('/')

            # set root tree

            tree = self.repository._repo[self._tree_id]

            if path == '':

                self._paths[''] = tree.id

                return tree.id

            splitted = path.split('/')

                for parent in self._commit.parents]

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        so, se = self.repository.run_git_command(

            "rev-list --all --children | grep '^%s'" % self.raw_id

        )

        children = []

        for l in so.splitlines():

            childs = l.split(' ')[1:]

            children.extend(childs)

        return [self.repository.get_changeset(cs) for cs in children]

    def next(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        def _next(changeset, branch):

            try:

                next_ = changeset.revision + 1

                next_rev = changeset.repository.revisions[next_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = changeset.repository.get_changeset(next_rev)

            if branch and branch != cs.branch:

                return _next(cs, branch)

            return cs

        return _next(self, branch)

    def prev(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        def _prev(changeset, branch):

            try:

                prev_ = changeset.revision - 1

                if prev_ < 0:

                    raise IndexError

                prev_rev = changeset.repository.revisions[prev_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = changeset.repository.get_changeset(prev_rev)

            if branch and branch != cs.branch:

                return _prev(cs, branch)

            return cs

        return _prev(self, branch)

    def diff(self, ignore_whitespace=True, context=3):

        rev1 = self.parents[0] if self.parents else self.repository.EMPTY_CHANGESET

        rev2 = self

        return ''.join(self.repository.get_diff(rev1, rev2,

                                    ignore_whitespace=ignore_whitespace,

                                    context=context))

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        # ensure path is traversed

        self._get_id_for_path(path)

        return self._stat_modes[path]

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        """

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.as_pretty_string()

    def get_file_size(self, path):

        """

        Returns size of the file at given ``path``.

        """

        id = self._get_id_for_path(path)

        blob = self.repository._repo[id]

        return blob.raw_length()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        TODO: This function now uses os underlying 'git' and 'grep' commands

        which is generally not good. Should be replaced with algorithm

        iterating commits.

        """

        self._get_filectx(path)

        so, se = self.repository.run_git_command(cmd)

        ids = re.findall(r'[0-9a-fA-F]{40}', so)

        return [self.repository.get_changeset(id) for id in ids]

    def get_file_history_2(self, path):

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        self._get_filectx(path)

        from dulwich.walk import Walker

        include = [self.id]

        walker = Walker(self.repository._repo.object_store, include,

                        paths=[path], max_entries=1)

        return [self.repository.get_changeset(sha)

                for sha in (x.commit.id for x in walker)]

    def get_file_annotate(self, path):

        """

        Returns a generator of four element tuples with

            lineno, sha, changeset lazy loader and line

        TODO: This function now uses os underlying 'git' command which is

        generally not good. Should be replaced with algorithm iterating

        commits.

        """

        cmd = 'blame -l --root -r %s -- "%s"' % (self.id, path)

        # -l     ==> outputs long shas (and we need all 40 characters)

        # --root ==> doesn't put '^' character for bounderies

        # -r sha ==> blames for the given revision

        so, se = self.repository.run_git_command(cmd)

        for i, blame_line in enumerate(so.split('\n')[:-1]):

            ln_no = i + 1

            sha, line = re.split(r' ', blame_line, 1)

            yield (ln_no, sha, lambda: self.repository.get_changeset(sha), line)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        allowed_kinds = settings.ARCHIVE_SPECS.keys()

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

                'of %s', allowed_kinds)

        if prefix is None:

            prefix = '%s-%s' % (self.repository.name, self.short_id)

        elif prefix.startswith('/'):

            raise VCSError("Prefix cannot start with leading slash")

        elif prefix.strip() == '':

            raise VCSError("Prefix cannot be empty")

        if kind == 'zip':

            frmt = 'zip'

        else:

            frmt = 'tar'

        _git_path = rhodecode.CONFIG.get('git_path', 'git')

        cmd = '%s archive --format=%s --prefix=%s/ %s' % (_git_path,

                                                frmt, prefix, self.raw_id)

        if kind == 'tgz':

            cmd += ' | gzip -9'

        elif kind == 'tbz2':

            cmd += ' | bzip2 -9'

        if stream is None:

            raise VCSError('You need to pass in a valid stream for filling'

                           ' with archival data')

        popen = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True,

            cwd=self.repository.path)

        buffer_size = 1024 * 8

        chunk = popen.stdout.read(buffer_size)

        while chunk:

            stream.write(chunk)

            chunk = popen.stdout.read(buffer_size)

        # Make sure all descriptors would be read

        popen.communicate()

    def get_nodes(self, path):

        if self._get_kind(path) != NodeKind.DIR:

            raise ChangesetError("Directory does not exist for revision %r at "

            return cs

        return _next(self, branch)

    def prev(self, branch=None):

        if branch and self.branch != branch:

            raise VCSError('Branch option used on changeset not belonging '

                           'to that branch')

        def _prev(changeset, branch):

            try:

                prev_ = changeset.revision - 1

                if prev_ < 0:

                    raise IndexError

                prev_rev = changeset.repository.revisions[prev_]

            except IndexError:

                raise ChangesetDoesNotExistError

            cs = changeset.repository.get_changeset(prev_rev)

            if branch and branch != cs.branch:

                return _prev(cs, branch)

            return cs

        return _prev(self, branch)

    def diff(self, ignore_whitespace=True, context=3):

        return ''.join(self._ctx.diff(git=True,

                                      ignore_whitespace=ignore_whitespace,

                                      context=context))

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed. Also mercurial keeps filenodes as str so we need to decode

        from unicode to str

        """

        if path.endswith('/'):

            path = path.rstrip('/')

        return safe_str(path)

    def _get_kind(self, path):

        path = self._fix_path(path)

        if path in self._file_paths:

            return NodeKind.FILE

        elif path in self._dir_paths:

            return NodeKind.DIR

        else:

            raise ChangesetError("Node does not exist at the given path %r"

                % (path))

    def _get_filectx(self, path):

        path = self._fix_path(path)

        if self._get_kind(path) != NodeKind.FILE:

            raise ChangesetError("File does not exist for revision %r at "

                " %r" % (self.raw_id, path))

        return self._ctx.filectx(path)

    def _extract_submodules(self):

        """

        returns a dictionary with submodule information from substate file

        of hg repository

        """

        return self._ctx.substate

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        fctx = self._get_filectx(path)

        if 'x' in fctx.flags():

            return 0100755

        else:

            return 0100644

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        """

        fctx = self._get_filectx(path)

        return fctx.data()

    def get_file_size(self, path):

        """

        Returns size of the file at given ``path``.

        """

        fctx = self._get_filectx(path)

        return fctx.size()

    def get_file_changeset(self, path):

        """

        Returns last commit of the file at the given ``path``.

        """

        """

        Returns history of file as reversed list of ``Changeset`` objects for

        which file at given ``path`` has been modified.

        """

        fctx = self._get_filectx(path)

    def get_file_annotate(self, path):

        """

        Returns a generator of four element tuples with

            lineno, sha, changeset lazy loader and line

        """

        fctx = self._get_filectx(path)

        for i, annotate_data in enumerate(fctx.annotate()):

            ln_no = i + 1

            sha = hex(annotate_data[0].node())

            yield (ln_no, sha, lambda: self.repository.get_changeset(sha), annotate_data[1],)

    def fill_archive(self, stream=None, kind='tgz', prefix=None,

                     subrepos=False):

        """

        Fills up given stream.

        :param stream: file like object.

        :param kind: one of following: ``zip``, ``tgz`` or ``tbz2``.

            Default: ``tgz``.

        :param prefix: name of root directory in archive.

            Default is repository name and changeset's raw_id joined with dash

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        allowed_kinds = settings.ARCHIVE_SPECS.keys()

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

                'of %s', allowed_kinds)

        if stream is None:

            raise VCSError('You need to pass in a valid stream for filling'

                           ' with archival data')

        if prefix is None:

            prefix = '%s-%s' % (self.repository.name, self.short_id)

        elif prefix.startswith('/'):

            raise VCSError("Prefix cannot start with leading slash")

        elif prefix.strip() == '':

            raise VCSError("Prefix cannot be empty")

        archival.archive(self.repository._repo, stream, self.raw_id,

                         kind, prefix=prefix, subrepos=subrepos)

        if stream.closed and hasattr(stream, 'name'):

            stream = open(stream.name, 'rb')

        elif hasattr(stream, 'mode') and 'r' not in stream.mode:

            stream = open(stream.name, 'rb')

        else:

            stream.seek(0)

    def get_nodes(self, path):

        """

        Returns combined ``DirNode`` and ``FileNode`` objects list representing

        state of changeset at the given ``path``. If node at the given ``path``

        is not instance of ``DirNode``, ChangesetError would be raised.

        """

        if self._get_kind(path) != NodeKind.DIR:

            raise ChangesetError("Directory does not exist for revision %r at "

                " %r" % (self.revision, path))

        path = self._fix_path(path)

        filenodes = [FileNode(f, changeset=self) for f in self._file_paths

            if os.path.dirname(f) == path]

        dirs = path == '' and '' or [d for d in self._dir_paths

            if d and posixpath.dirname(d) == path]

        dirnodes = [DirNode(d, changeset=self) for d in dirs

            if os.path.dirname(d) == path]

        als = self.repository.alias

        for k, vals in self._extract_submodules().iteritems():

            #vals = url,rev,type

            loc = vals[0]

            cs = vals[1]

            dirnodes.append(SubModuleNode(k, url=loc, changeset=cs,

                                          alias=als))

        nodes = dirnodes + filenodes

        # cache nodes

        for node in nodes:

            self.nodes[node.path] = node

        nodes.sort()

        return nodes

    def get_node(self, path):

        """

        Returns ``Node`` object from the given ``path``. If there is no node at

        the given ``path``, ``ChangesetError`` would be raised.

        """

<%def name="file_class(node)">

    %if node.is_file():

        <%return "browser-file" %>

    %else:

        <%return "browser-dir"%>

    %endif

</%def>

<div id="body" class="browserblock">

    <div class="browser-header">

        <div class="browser-nav">

            ${h.form(h.url.current())}

            <div class="info_box">

              <span class="rev">${_('view')}@rev</span>

              <a class="ui-btn ypjax-link" href="${c.url_prev}" title="${_('previous revision')}">&laquo;</a>

              ${h.text('at_rev',value=c.changeset.revision,size=5)}

              <a class="ui-btn ypjax-link" href="${c.url_next}" title="${_('next revision')}">&raquo;</a>

              ## ${h.submit('view',_('view'),class_="ui-btn")}

            </div>

            ${h.end_form()}

        </div>

        <div class="browser-branch">

           ${h.checkbox('stay_at_branch',c.changeset.branch,c.changeset.branch==c.branch)}

           <label>${_('follow current branch')}</label>

        </div>

        <div class="browser-search">

              <div id="search_activate_id" class="search_activate">

                  <a class="ui-btn" id="filter_activate" href="#">${_('search file list')}</a>

              </div>

              % if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):

                    <div id="add_node_id" class="add_node">

                        <a class="ui-btn" href="${h.url('files_add_home',repo_name=c.repo_name,revision=c.changeset.raw_id,f_path=c.f_path)}">${_('add new file')}</a>

                    </div>

              % endif

        <div>

            <div id="node_filter_box_loading" style="display:none">${_('Loading file list...')}</div>

            <div id="node_filter_box" style="display:none">

            ${h.files_breadcrumbs(c.repo_name,c.changeset.raw_id,c.file.path)}/<input class="init" type="text" value="type to search..." name="filter" size="25" id="node_filter" autocomplete="off">

            </div>

        </div>

        </div>

    </div>

    <div class="browser-body">

        <table class="code-browser">

            <thead>

                <tr>

                    <th>${_('Name')}</th>

                    <th>${_('Size')}</th>

                    <th>${_('Mimetype')}</th>

                    <th>${_('Last Revision')}</th>

                    <th>${_('Last modified')}</th>

                    <th>${_('Last committer')}</th>

                </tr>

            </thead>

            <tbody id="tbody">

                %if c.file.parent:

                <tr class="parity0">

                    <td>