from rhodecode.lib.vcs.backends.git.repository import GitRepository

    from distutils.version import StrictVersion

    stdout, stderr = GitRepository._run_git_command('--version', _bare=True,

                                                    _safe=True)

    ver = (stdout.split(' ')[-1] or '').strip() or '0.0.0'

    if len(ver.split('.')) > 3:

        #StrictVersion needs to be only 3 element type

        ver = '.'.join(ver.split('.')[:3])

    try:

        _ver = StrictVersion(ver)

    except:

        _ver = StrictVersion('0.0.0')

        stderr = traceback.format_exc()

    req_ver = '1.7.4'

    to_old_git = False

    if  _ver < StrictVersion(req_ver):

        to_old_git = True

    if 'git' in BACKENDS:

        log.debug('GIT version detected: %s' % stdout)

        if stderr:

        elif to_old_git:

            log.warning('RhodeCode detected git version %s, which is too old '

                        'for the system to function properly. Make sure '

                        'its version is at least %s' % (ver, req_ver))

    return _ver

@decorator.decorator

def jsonify(func, *args, **kwargs):

    """Action decorator that formats output for JSON

    Given a function that will return content, this decorator will turn

    the result into JSON, with a content-type of 'application/json' and

    output it.

    """

    from pylons.decorators.util import get_pylons

    from rhodecode.lib.ext_json import json

    pylons = get_pylons(args)

    pylons.response.headers['Content-Type'] = 'application/json; charset=utf-8'

    data = func(*args, **kwargs)

    if isinstance(data, (list, tuple)):

        msg = "JSON responses with Array envelopes are susceptible to " \

              "cross-site data leak attacks, see " \

                else:

                    curdir = dir

                dir_id = None

                for item, stat, id in tree.iteritems():

                    if dir == item:

                        dir_id = id

                if dir_id:

                    # Update tree

                    tree = self.repository._repo[dir_id]

                    if not isinstance(tree, objects.Tree):

                        raise ChangesetError('%s is not a directory' % curdir)

                else:

                    raise ChangesetError('%s have not been found' % curdir)

                # cache all items from the given traversed tree

                for item, stat, id in tree.iteritems():

                    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 "

                    % (path, self.short_id))

        return self._paths[path]

    def _get_kind(self, path):

        obj = self.repository._repo[self._get_id_for_path(path)]

        if isinstance(obj, objects.Blob):

            return NodeKind.FILE

        elif isinstance(obj, objects.Tree):

            return NodeKind.DIR

    def _get_filectx(self, path):

        path = self._fix_path(path)

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

        return path

    def _get_file_nodes(self):

        return chain(*(t[2] for t in self.walk()))

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        return [self.repository.get_changeset(parent)

                for parent in self._commit.parents]

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        rev_filter = _git_path = rhodecode.CONFIG.get('git_rev_filter',

                                              '--all').strip()

        so, se = self.repository.run_git_command(

            "rev-list %s --children | grep '^%s'" % (rev_filter, self.raw_id)

        )

        _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:

        path = self._fix_path(path)

        id = self._get_id_for_path(path)

        tree = self.repository._repo[id]

        dirnodes = []

        filenodes = []

        als = self.repository.alias

        for name, stat, id in tree.iteritems():

            if objects.S_ISGITLINK(stat):

                dirnodes.append(SubModuleNode(name, url=None, changeset=id,

                                              alias=als))

                continue

            obj = self.repository._repo.get_object(id)

            if path != '':

                obj_path = '/'.join((path, name))

            else:

                obj_path = name

            if obj_path not in self._stat_modes:

                self._stat_modes[obj_path] = stat

            if isinstance(obj, objects.Tree):

                dirnodes.append(DirNode(obj_path, changeset=self))

            elif isinstance(obj, objects.Blob):

                filenodes.append(FileNode(obj_path, changeset=self, mode=stat))

            else:

            try:

                id_ = self._get_id_for_path(path)

            except ChangesetError:

                raise NodeDoesNotExistError("Cannot find one of parents' "

                    "directories for a given path: %s" % path)

            _GL = lambda m: m and objects.S_ISGITLINK(m)

            if _GL(self._stat_modes.get(path)):

                node = SubModuleNode(path, url=None, changeset=id_,

                                     alias=self.repository.alias)

            else:

                obj = self.repository._repo.get_object(id_)

                if isinstance(obj, objects.Tree):

                    if path == '':

                        node = RootNode(changeset=self)

                    else:

                        node = DirNode(path, changeset=self)

                    node._tree = obj

                elif isinstance(obj, objects.Blob):

                    node = FileNode(path, changeset=self)

                    node._blob = obj

                else:

                    raise NodeDoesNotExistError("There is no file nor directory "

                        % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        Get's a fast accessible file changes for given changeset

        """

        a, m, d = self._changes_cache

        return list(a.union(m).union(d))

    @LazyProperty

    def _diff_name_status(self):

        output = []

        for parent in self.parents:

            cmd = 'diff --name-status %s %s --encoding=utf8' % (parent.raw_id,

                                                                self.raw_id)

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

            output.append(so.strip())

        return '\n'.join(output)

    @LazyProperty

        includes = [x[1][0] for x in self._parsed_refs.iteritems()

                    if x[1][1] != 'T']

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        For git backend we always return integer here. This way we ensure

        that changset's revision attribute would become integer.

        """

        pattern = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$')

        is_bstr = lambda o: isinstance(o, (str, unicode))

        is_null = lambda o: len(o) == revision.count('0')

        if len(self.revisions) == 0:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in (None, '', 'tip', 'HEAD', 'head', -1):

            revision = self.revisions[-1]

        if ((is_bstr(revision) and revision.isdigit() and len(revision) < 12)

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

            except:

                    "for this repository" % (revision))

        elif is_bstr(revision):

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

            _tags_shas = self.tags.values()

            if _ref_revision:  # and _ref_revision[1] in ['H', 'RH', 'T']:

                return _ref_revision[0]

            # maybe it's a tag ? we don't have them in self.revisions

            elif revision in _tags_shas:

                return _tags_shas[_tags_shas.index(revision)]

            elif not pattern.match(revision) or revision not in self.revisions:

                    "for this repository" % (revision))

        # Ensure we return full id

        if not pattern.match(str(revision)):

                % revision)

        return revision

    def _get_archives(self, archive_name='tip'):

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall to

        filesystem (``file:///``) schema.

        """

        url = str(url)

        if url != 'default' and not '://' in url:

            url = ':///'.join(('file', url))

        return url

    def get_hook_location(self):

        """

        returns absolute path to location where hooks are stored

        """

        loc = os.path.join(self.path, 'hooks')

        if not self.bare:

    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:

                % (path))

    def _get_filectx(self, path):

        path = self._fix_path(path)

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

        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)

            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:

        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.

        """

        path = self._fix_path(path)

        if not path in self.nodes:

            if path in self._file_paths:

                node = FileNode(path, changeset=self)

            elif path in self._dir_paths or path in self._dir_paths:

                if path == '':

                    node = RootNode(changeset=self)

                else:

                    node = DirNode(path, changeset=self)

            else:

                raise NodeDoesNotExistError("There is no file nor directory "

                    % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        Get's a fast accessible file changes for given changeset

        """

        return self._ctx.files()

    @property

    def added(self):

        """

        Returns list of added ``FileNode`` objects.

        """

        return AddedFileNodesGenerator([n for n in self.status[1]], self)

    @property

    def changed(self):

        """

        Returns list of modified ``FileNode`` objects.

        """

                return os.stat(cl_path).st_mtime

            else:

                return os.stat(st_path).st_mtime

    def _get_hidden(self):

        return self._repo.ui.configbool("web", "hidden", untrusted=True)

    def _get_revision(self, revision):

        """

        Get's an ID revision given as str. This will always return a fill

        40 char revision number

        :param revision: str or int or None

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, 'tip', None]:

            revision = 'tip'

        try:

            revision = hex(self._repo.lookup(revision))

        except (IndexError, ValueError, RepoLookupError, TypeError):

                                    "exist for this repository"

                                    % (revision))

        return revision

    def _get_archives(self, archive_name='tip'):

        allowed = self.baseui.configlist("web", "allow_archive",

                                         untrusted=True)

        for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:

            if i[0] in allowed or self._repo.ui.configbool("web",

                                                           "allow" + i[0],

                                                           untrusted=True):

                yield {"type": i[0], "extension": i[1], "node": archive_name}

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = str(url)

        if url != 'default' and not '://' in url:

            url = "file:" + urllib.pathname2url(url)

        return url

    #==========================================================================

    # RAW FILE

    #==========================================================================

    def test_raw_file_ok(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

        self.assertEqual(response.content_disposition, "attachment; filename=nodes.py")

        self.assertEqual(response.content_type, "text/x-python")

    def test_raw_file_wrong_cs(self):

        self.log_user()

        rev = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/nodes.py'

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        self.checkSessionFlash(response, msg)

        self.assertEqual('http://localhost/%s/files/tip/' % HG_REPO, response.headers['location'])

    def test_raw_file_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        self.checkSessionFlash(response, msg)

    #==========================================================================

    # RAW RESPONSE - PLAIN

    #==========================================================================

    def test_raw_ok(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

        self.assertEqual(response.content_type, "text/plain")

    def test_raw_wrong_cs(self):

        self.log_user()

        rev = u'ERRORcce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/nodes.py'

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        self.checkSessionFlash(response, msg)

        self.assertEqual('http://localhost/%s/files/tip/' % HG_REPO, response.headers['location'])

    def test_raw_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        self.checkSessionFlash(response, msg)

    def test_ajaxed_files_list(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        response = self.app.get(

            url('files_nodelist_home', repo_name=HG_REPO,f_path='/',revision=rev),

            extra_environ={'HTTP_X_PARTIAL_XHR': '1'},

        )

        response.mustcontain("vcs/web/simplevcs/views/repository.py")