else:

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

                % (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 %s at "

                " '%s'" % (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():

        else:

    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``.

        """

        return self.get_file_history(path, limit=1)[0]

    def get_file_history(self, path, limit=None):

        """

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

    Class representing file nodes.

    :attribute: path: path to the node, relative to repository's root

    :attribute: content: if given arbitrary sets content of the file

    :attribute: changeset: if given, first time content is accessed, callback

    :attribute: mode: octal stat mode for a node. Default is 0100644.

    """

    def __init__(self, path, content=None, changeset=None, mode=None):

        """

        Only one of ``content`` and ``changeset`` may be given. Passing both

        would raise ``NodeError`` exception.

        :param path: relative path to the node

        :param content: content may be passed to constructor

        :param changeset: if given, will use it to lazily fetch content

        :param mode: octal representation of ST_MODE (i.e. 0100644)

        """

        if content and changeset:

            raise NodeError("Cannot use both content and changeset")

        super(FileNode, self).__init__(path, kind=NodeKind.FILE)

        self.changeset = changeset

        self._content = content

    @LazyProperty

    def mode(self):

        """

        Returns lazily mode of the FileNode. If ``changeset`` is not set, would

        use value given at initialization or 0100644 (default).

        """

        if self.changeset:

            mode = self.changeset.get_file_mode(self.path)

        else:

            mode = self._mode

        return mode

    def _get_content(self):

        if self.changeset:

            content = self.changeset.get_file_content(self.path)

        else:

            content = self._content

        return content

    @property

    def content(self):

        """

        Returns lazily content of the FileNode. If possible, would try to

            if os.path.exists(_hook_file):

                # let's take a look at this hook, maybe it's kallithea ?

                log.debug('hook exists, checking if it is from kallithea')

                with open(_hook_file, 'rb') as f:

                    data = f.read()

                    matches = re.compile(r'(?:%s)\s*=\s*(.*)'

                                         % 'KALLITHEA_HOOK_VER').search(data)

                    if matches:

                        try:

                            ver = matches.groups()[0]

                            log.debug('got %s it is kallithea', ver)

                            has_hook = True

                        except Exception:

                            log.error(traceback.format_exc())

            else:

                # there is no hook in this dir, so we want to create one

                has_hook = True

            if has_hook or force_create:

                log.debug('writing %s hook file !', h_type)

                try:

                    with open(_hook_file, 'wb') as f:

                        tmpl = tmpl.replace('_TMPL_', kallithea.__version__)

                        f.write(tmpl)

                except IOError as e:

                    log.error('error writing %s: %s', _hook_file, e)

            else:

                log.debug('skipping writing hook file')

def AvailableRepoGroupChoices(top_perms, repo_group_perm_level, extras=()):

    """Return group_id,string tuples with choices for all the repo groups where

    the user has the necessary permissions.

    Top level is -1.

    """

    groups = RepoGroup.query().all()

    if HasPermissionAny('hg.admin')('available repo groups'):

        groups.append(None)

    else:

        groups = list(RepoGroupList(groups, perm_level=repo_group_perm_level))

        if top_perms and HasPermissionAny(*top_perms)('available repo groups'):

            groups.append(None)

        for extra in extras:

            if not any(rg == extra for rg in groups):

                groups.append(extra)

    return RepoGroup.groups_choices(groups=groups)

        with pytest.raises(VCSError):

            changeset.added

    def test_error_is_raised_for_removed_if_diff_name_status_is_wrong(self):

        repo = mock.MagicMock()

        changeset = GitChangeset(repo, 'foobar')

        changeset._diff_name_status = 'foobar'

        with pytest.raises(VCSError):

            changeset.added

class TestGitSpecificWithRepo(_BackendTestMixin):

    backend_alias = 'git'

    @classmethod

    def _get_commits(cls):

        return [

            {

                'message': 'Initial',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('foobar/static/js/admin/base.js', content='base'),

                    FileNode('foobar/static/admin', content='admin',

                    FileNode('foo', content='foo'),

                ],

            },

            {

                'message': 'Second',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 22),

                'added': [

                    FileNode('foo2', content='foo2'),

                ],

            },

        ]

    def test_paths_slow_traversing(self):

        cs = self.repo.get_changeset()

        assert cs.get_node('foobar').get_node('static').get_node('js').get_node('admin').get_node('base.js').content == 'base'

    def test_paths_fast_traversing(self):

        cs = self.repo.get_changeset()

        assert cs.get_node('foobar/static/js/admin/base.js').content == 'base'

    def test_workdir_get_branch(self):

        self.repo.run_git_command(['checkout', '-b', 'production'])

        # Regression test: one of following would fail if we don't check

        """

        Without link to changeset nodes should raise NodeError.

        """

        node = FileNode('anything')

        with pytest.raises(NodeError):

            getattr(node, 'state')

        node = DirNode('anything')

        with pytest.raises(NodeError):

            getattr(node, 'state')

    def test_file_node_stat(self):

        node = FileNode('foobar', 'empty... almost')

        mode = node.mode  # default should be 0100644

        assert mode & stat.S_IRUSR

        assert mode & stat.S_IWUSR

        assert mode & stat.S_IRGRP

        assert mode & stat.S_IROTH

        assert not mode & stat.S_IWGRP

        assert not mode & stat.S_IWOTH

        assert not mode & stat.S_IXUSR

        assert not mode & stat.S_IXGRP

        assert not mode & stat.S_IXOTH

    def test_file_node_is_executable(self):

        assert node.is_executable

        assert node.is_executable

        assert not node.is_executable

    def test_mimetype(self):

        py_node = FileNode('test.py')

        tar_node = FileNode('test.tar.gz')

        my_node2 = FileNode('myfile2')

        my_node2._content = 'foobar'

        my_node3 = FileNode('myfile3')

        my_node3._content = '\0foobar'

        assert py_node.mimetype == mimetypes.guess_type(py_node.name)[0]

        assert py_node.get_mimetype() == mimetypes.guess_type(py_node.name)

        assert tar_node.mimetype == mimetypes.guess_type(tar_node.name)[0]

        assert tar_node.get_mimetype() == mimetypes.guess_type(tar_node.name)

        assert my_node2.mimetype == 'text/plain'

        assert my_node2.get_mimetype() == ('text/plain', None)

        assert my_node3.mimetype == 'application/octet-stream'

        assert my_node3.get_mimetype() == ('application/octet-stream', None)