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

                    if curdir:

                        name = '/'.join((curdir, item))

                    else:

                        name = item

                    self._paths[name] = id

                    self._stat_modes[name] = stat

            if not path in self._paths:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path %r at revision %r"

                    % (path, self.short_id))

        return self._paths[path]

        return self.added + self.changed

    @LazyProperty

    def _diff_name_status(self):

        output = []

        for parent in self.parents:

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

            output.append(so.strip())

        return '\n'.join(output)

    def _get_paths_for_status(self, status):

        """

        """

        paths = set()

        char = status[0].upper()

        for line in self._diff_name_status.splitlines():

            if not line:

                continue

            if line.startswith(char):

                splitted = line.split(char,1)

                if not len(splitted) == 2:

                    raise VCSError("Couldn't parse diff result:\n%s\n\n and "

                        "particularly that line: %s" % (self._diff_name_status,

                        line))

        return sorted(paths)

    @LazyProperty

    def added(self):

        """

        Returns list of added ``FileNode`` objects.

import datetime

import posixpath

from dulwich import objects

from dulwich.repo import Repo

from rhodecode.lib.vcs.backends.base import BaseInMemoryChangeset

from rhodecode.lib.vcs.exceptions import RepositoryError

class GitInMemoryChangeset(BaseInMemoryChangeset):

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

            **kwargs):

        object_store.add_object(commit_tree)

        # Create commit

        commit = objects.Commit()

        commit.tree = commit_tree.id

        commit.parents = [p._commit.id for p in self.parents if p]

        commit.encoding = ENCODING

        # Compute date

        if date is None:

            date = time.time()

        elif isinstance(date, datetime.datetime):

            date = time.mktime(date.timetuple())

           at Dulwich (see https://bugs.launchpad.net/bugs/645142). Parsing

           os command's output is road to hell...

        :param cmd: git command to be executed

        """

        if isinstance(cmd, basestring):

        try:

            opts = dict(

                shell=isinstance(cmd, basestring),

                stdout=PIPE,

                stderr=PIPE)

            if os.path.isdir(self.path):

import datetime

import errno

from rhodecode.lib.vcs.backends.base import BaseInMemoryChangeset

from rhodecode.lib.vcs.exceptions import RepositoryError

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

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

            **kwargs):

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

        """

        self.check_integrity(parents)

        from .repository import MercurialRepository

            raise RepositoryError('Given message and author needs to be '

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

        kwargs['branch'] = branch

        def filectxfn(_repo, memctx, path):

            files=self.get_paths(),

            filectxfn=filectxfn,

            user=author,

            date=date,

            extra=kwargs)

        # injecting given _repo params

        commit_ctx._date = date

        # TODO: Catch exceptions!

        n = self.repository._repo.commitctx(commit_ctx)

        # Returns mercurial node

        self._commit_ctx = commit_ctx  # For reference

            if self.changeset:

                return self.changeset.get_node(parent_path)

            return DirNode(parent_path)

        return None

    @LazyProperty

    def name(self):

        """

        Returns name of the node so if its path

        then only last part is returned.

        """

        return safe_unicode(self.path.rstrip('/').split('/')[-1])

from mercurial import archival, merge as hg_merge, patch, ui

from mercurial.commands import clone, nullid, pull

from mercurial.context import memctx, memfilectx

from mercurial.error import RepoError, RepoLookupError, Abort

from mercurial.hgweb.common import get_contact

from mercurial.localrepo import localrepository

from mercurial.match import match

from mercurial.mdiff import diffopts

from mercurial.node import hex

from rhodecode.lib.vcs.exceptions import RepositoryError

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

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny

from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \

    action_logger, EmptyChangeset, REMOVED_REPO_PAT

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup

        elif repo.alias == 'git':

            from rhodecode.lib.vcs.backends.git import GitInMemoryChangeset as IMC

        # decoding here will force that we have proper encoded values

        # in any other case this will throw exceptions and deny commit

        content = safe_str(content)

        path = safe_str(f_path)

        m = IMC(repo)

        m.change(FileNode(path, content))

        tip = m.commit(message=message,

                 author=author,

                 parents=[cs], branch=cs.branch)

            content = content.read()

        else:

            raise Exception('Content is of unrecognized type %s' % (

                type(content)

            ))

        path = safe_str(f_path)

        m = IMC(repo)

        if isinstance(cs, EmptyChangeset):

            parents = None

        else:

            parents = [cs]

        m.add(FileNode(path, content=content))

        tip = m.commit(message=message,

                       % if not c.file.is_binary:

                        ${h.link_to(_('source'),h.url('files_home',repo_name=c.repo_name,revision=c.cs.raw_id,f_path=c.f_path),class_="ui-btn")}

                       % endif

                      % endif

                    </div>

                </div>

            </div>

			    <pre id="editor_pre"></pre>

				<textarea id="editor" name="content" style="display:none">${h.escape(c.file.content)|n}</textarea>

				<div style="padding: 10px;color:#666666">${_('commit message')}</div>

				<textarea id="commit" name="message" style="height: 60px;width: 99%;margin-left:4px"></textarea>

			</div>