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._commiter_property = 'committer'

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

        return safe_unicode(getattr(self._commit, self._commiter_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 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]

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

"""

    vcs.backends.git

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

    Git backend implementation.

    :created_on: Apr 8, 2010

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

"""

import os

import re

import time

import posixpath

import logging

import traceback

import urllib

import urllib2

from dulwich.repo import Repo, NotGitRepository

from string import Template

from subprocess import Popen, PIPE

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

from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import TagAlreadyExistError

from rhodecode.lib.vcs.exceptions import TagDoesNotExistError

from rhodecode.lib.vcs.utils import safe_unicode, makedate, date_fromtimestamp

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

from rhodecode.lib.vcs.utils.ordered_dict import OrderedDict

from rhodecode.lib.vcs.utils.paths import abspath

from rhodecode.lib.vcs.utils.paths import get_user_home

from .workdir import GitWorkdir

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .config import ConfigFile

from rhodecode.lib import subprocessio

log = logging.getLogger(__name__)

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        tagpath = posixpath.join(self._repo.refs.path, 'refs', 'tags', name)

        try:

            os.remove(tagpath)

            self._parsed_refs = self._get_parsed_refs()

            self.tags = self._get_tags()

        except OSError, e:

            raise RepositoryError(e.strerror)

    @LazyProperty

    def _parsed_refs(self):

        return self._get_parsed_refs()

    def _get_parsed_refs(self):

        refs = self._repo.get_refs()

        keys = [('refs/heads/', 'H'),

                ('refs/remotes/origin/', 'RH'),

                ('refs/tags/', 'T')]

        _refs = {}

        for ref, sha in refs.iteritems():

            for k, type_ in keys:

                if ref.startswith(k):

                    _key = ref[len(k):]

                    _refs[_key] = [sha, type_]

                    break

        return _refs

    def _heads(self, reverse=False):

        refs = self._repo.get_refs()

        heads = {}

        for key, val in refs.items():

            for ref_key in ['refs/heads/', 'refs/remotes/origin/']:

                if key.startswith(ref_key):

                    n = key[len(ref_key):]

                    if n not in ['HEAD']:

                        heads[n] = val

        return heads if reverse else dict((y, x) for x, y in heads.iteritems())

    def get_changeset(self, revision=None):

        """

        Returns ``GitChangeset`` object representing commit from git repository

        at the given revision or head (most recent commit) if None given.

        """

        if isinstance(revision, GitChangeset):

            return revision