@LazyProperty

    def not_changed(self):

        return self.state is NodeState.NOT_CHANGED

    @LazyProperty

    def removed(self):

        return self.state is NodeState.REMOVED

class FileNode(Node):

    """

    Class representing file nodes.

    :attribute: path: path to the node, relative to repostiory'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

        self._mode = mode or 0100644

    @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

        decode content from UTF-8.

        """

        content = self._get_content()

        if bool(content and '\0' in content):

            return content

        return safe_unicode(content)

    @LazyProperty

    def size(self):

        if self.changeset:

            return self.changeset.get_file_size(self.path)

        raise NodeError("Cannot retrieve size of the file without related "

            "changeset attribute")

    @LazyProperty

    def message(self):

        if self.changeset:

            return self.last_changeset.message

        raise NodeError("Cannot retrieve message of the file without related "

            "changeset attribute")

    @LazyProperty

    def last_changeset(self):

        if self.changeset:

            return self.changeset.get_file_changeset(self.path)

        raise NodeError("Cannot retrieve last changeset of the file without "

            "related changeset attribute")

    def get_mimetype(self):

        """

        Mimetype is calculated based on the file's content. If ``_mimetype``

        attribute is available, it will be returned (backends which store

        mimetypes or can easily recognize them, should set this private

        attribute to indicate that type should *NOT* be calculated).

        """

        if hasattr(self, '_mimetype'):

            if (isinstance(self._mimetype, (tuple, list,)) and

                len(self._mimetype) == 2):

                return self._mimetype

            else:

                raise NodeError('given _mimetype attribute must be an 2 '

                               'element list or tuple')

        mtype, encoding = mimetypes.guess_type(self.name)

        if mtype is None:

            if self.is_binary:

                mtype = 'application/octet-stream'

                encoding = None

            else:

                mtype = 'text/plain'

                encoding = None

        return mtype, encoding

    @LazyProperty

    def mimetype(self):

        """

        Wrapper around full mimetype info. It returns only type of fetched

        mimetype without the encoding part. use get_mimetype function to fetch

        full set of (type,encoding)

        """

        return self.get_mimetype()[0]

    @LazyProperty

    def mimetype_main(self):

        return self.mimetype.split('/')[0]

    @LazyProperty

    def lexer(self):

        """

        Returns pygment's lexer class. Would try to guess lexer taking file's

        content, name and mimetype.

        """

        try:

            lexer = lexers.guess_lexer_for_filename(self.name, self.content, stripnl=False)

        except lexers.ClassNotFound:

            lexer = lexers.TextLexer(stripnl=False)

        # returns first alias

        return lexer

    @LazyProperty

    def lexer_alias(self):

        """

        Returns first alias of the lexer guessed for this file.

        """

        return self.lexer.aliases[0]

    @LazyProperty

    def history(self):

        """

        Returns a list of changeset for this file in which the file was changed

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_history(self.path)

    @LazyProperty

    def annotate(self):

        """

        Returns a list of three element tuples with lineno,changeset and line

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_annotate(self.path)

    @LazyProperty

    def state(self):

        if not self.changeset:

            raise NodeError("Cannot check state of the node if it's not "

                "linked with changeset")

        elif self.path in (node.path for node in self.changeset.added):

            return NodeState.ADDED

        elif self.path in (node.path for node in self.changeset.changed):

            return NodeState.CHANGED

        else:

            return NodeState.NOT_CHANGED

    @property

    def is_binary(self):

        """

        Returns True if file has binary content.

        """

        _bin = '\0' in self._get_content()

        return _bin

    @LazyProperty

    def extension(self):

        """Returns filenode extension"""

        return self.name.split('.')[-1]

    def is_executable(self):

        """

        Returns ``True`` if file has executable flag turned on.

        """

        return bool(self.mode & stat.S_IXUSR)

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

                                 getattr(self.changeset, 'short_id', ''))

class RemovedFileNode(FileNode):

    """

    Dummy FileNode class - trying to access any public attribute except path,

    name, kind or state (or methods/attributes checking those two) would raise

    RemovedFileNodeError.

    """

    ALLOWED_ATTRIBUTES = [

        'name', 'path', 'state', 'is_root', 'is_file', 'is_dir', 'kind',

        'added', 'changed', 'not_changed', 'removed'

    ]

    def __init__(self, path):

        """

        :param path: relative path to the node

        """

        super(RemovedFileNode, self).__init__(path=path)

    def __getattribute__(self, attr):

        if attr.startswith('_') or attr in RemovedFileNode.ALLOWED_ATTRIBUTES:

            return super(RemovedFileNode, self).__getattribute__(attr)

        raise RemovedFileNodeError("Cannot access attribute %s on "

            "RemovedFileNode" % attr)

    @LazyProperty

    def state(self):

        return NodeState.REMOVED

class DirNode(Node):

    """

    DirNode stores list of files and directories within this node.

    Nodes may be used standalone but within repository context they

    lazily fetch data within same repositorty's changeset.

    """

    def __init__(self, path, nodes=(), changeset=None):

        """

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

        would raise ``NodeError`` exception.

        :param path: relative path to the node

        :param nodes: content may be passed to constructor

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

        :param size: always 0 for ``DirNode``

        """

        if nodes and changeset:

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

        super(DirNode, self).__init__(path, NodeKind.DIR)

        self.changeset = changeset

        self._nodes = nodes

    @LazyProperty

    def content(self):

        raise NodeError("%s represents a dir and has no ``content`` attribute"

            % self)

    @LazyProperty

    def nodes(self):

        if self.changeset:

            nodes = self.changeset.get_nodes(self.path)

        else:

            nodes = self._nodes

        self._nodes_dict = dict((node.path, node) for node in nodes)

        return sorted(nodes)

    @LazyProperty

    def files(self):

        return sorted((node for node in self.nodes if node.is_file()))

    @LazyProperty

    def dirs(self):

        return sorted((node for node in self.nodes if node.is_dir()))

    def __iter__(self):

        for node in self.nodes:

            yield node

    def get_node(self, path):

        """

        Returns node from within this particular ``DirNode``, so it is now

        allowed to fetch, i.e. node located at 'docs/api/index.rst' from node

        'docs'. In order to access deeper nodes one must fetch nodes between

        them first - this would work::

           docs = root.get_node('docs')

           docs.get_node('api').get_node('index.rst')

        :param: path - relative to the current node

        .. note::

           To access lazily (as in example above) node have to be initialized

           with related changeset object - without it node is out of

           context and may know nothing about anything else than nearest

           (located at same level) nodes.

        """

        try:

            path = path.rstrip('/')

            if path == '':

                raise NodeError("Cannot retrieve node without path")

            self.nodes  # access nodes first in order to set _nodes_dict

            paths = path.split('/')

            if len(paths) == 1:

                if not self.is_root():

                    path = '/'.join((self.path, paths[0]))

                else:

                    path = paths[0]

                return self._nodes_dict[path]

            elif len(paths) > 1:

                if self.changeset is None:

                    raise NodeError("Cannot access deeper "

                                    "nodes without changeset")

                else:

                    path1, path2 = paths[0], '/'.join(paths[1:])

                    return self.get_node(path1).get_node(path2)

            else:

                raise KeyError

        except KeyError:

            raise NodeError("Node does not exist at %s" % path)

    @LazyProperty

    def state(self):

        raise NodeError("Cannot access state of DirNode")

    @LazyProperty

    def size(self):

        size = 0

        for root, dirs, files in self.changeset.walk(self.path):

            for f in files:

                size += f.size

        return size

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

                                 getattr(self.changeset, 'short_id', ''))

class RootNode(DirNode):

    """

    DirNode being the root node of the repository.

    """

    def __init__(self, nodes=(), changeset=None):

        super(RootNode, self).__init__(path='', nodes=nodes,

            changeset=changeset)

    def __repr__(self):

        return '<%s>' % self.__class__.__name__

class SubModuleNode(Node):

    """

    represents a SubModule of Git or SubRepo of Mercurial

    """

    is_binary = False

    size = 0

    def __init__(self, name, url=None, changeset=None, alias=None):

        self.path = name

        self.kind = NodeKind.SUBMODULE

        self.alias = alias

        # we have to use emptyChangeset here since this can point to svn/git/hg

        # submodules we cannot get from repository

        self.changeset = EmptyChangeset(str(changeset), alias=alias)

        self.url = url or self._extract_submodule_url()

    def __repr__(self):

        return '<%s %r @ %s>' % (self.__class__.__name__, self.path,

                                 getattr(self.changeset, 'short_id', ''))

    def _extract_submodule_url(self):

        if self.alias == 'git':

            #TODO: find a way to parse gits submodule file and extract the

            # linking URL

            return self.path

        if self.alias == 'hg':

            return self.path

    @LazyProperty

    def name(self):

        """

            repo.update_changeset_cache()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repo_id == follow_repo_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                return

            except Exception:

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_repo_id = follow_repo_id

            self.sa.add(f)

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

        except Exception:

            log.error(traceback.format_exc())

            raise

    def toggle_following_user(self, follow_user_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user_id == follow_user_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                return

            except Exception:

                log.error(traceback.format_exc())

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

            self.sa.add(f)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def is_following_repo(self, repo_name, user_id, cache=False):

        r = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repository == r)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def is_following_user(self, username, user_id, cache=False):

        u = User.get_by_username(username)

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo):

        repo = self._get_repo(repo)

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repository == repo).count()

    def get_forks(self, repo):

        repo = self._get_repo(repo)

        return self.sa.query(Repository)\

                .filter(Repository.fork == repo).count()

    def get_pull_requests(self, repo):

        repo = self._get_repo(repo)

        return self.sa.query(PullRequest)\

                .filter(PullRequest.other_repo == repo)\

                .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()

    def mark_as_fork(self, repo, fork, user):

        repo = self.__get_repo(repo)

        fork = self.__get_repo(fork)

        if fork and repo.repo_id == fork.repo_id:

            raise Exception("Cannot set repository as fork of itself")

        repo.fork = fork

        self.sa.add(repo)

        return repo

    def _handle_rc_scm_extras(self, username, repo_name, repo_alias):

        from rhodecode import CONFIG

        from rhodecode.lib.base import _get_ip_addr

        try:

            from pylons import request

            environ = request.environ

        except TypeError:

            # we might use this outside of request context, let's fake the

            # environ data

            from webob import Request

            environ = Request.blank('').environ

        extras = {

            'ip': _get_ip_addr(environ),

            'username': username,

            'action': 'push_local',

            'repository': repo_name,

            'scm': repo_alias,

            'config': CONFIG['__file__'],

            'server_url': get_server_url(environ),

            'make_lock': None,

            'locked_by': [None, None]

        }

        _set_extras(extras)

    def _handle_push(self, repo, username, action, repo_name, revisions):

        """

        Triggers push action hooks

        :param repo: SCM repo

        :param username: username who pushes

        :param action: push/push_loca/push_remote

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        self._handle_rc_scm_extras(username, repo_name, repo_alias=repo.alias)

        _scm_repo = repo._repo

        # trigger push hook

        if repo.alias == 'hg':

            log_push_action(_scm_repo.ui, _scm_repo, node=revisions[0])

        elif repo.alias == 'git':

            log_push_action(None, _scm_repo, _git_revs=revisions)

    def _get_IMC_module(self, scm_type):

        """

        Returns InMemoryCommit class based on scm_type

        :param scm_type:

        """

        if scm_type == 'hg':

            from rhodecode.lib.vcs.backends.hg import \

                MercurialInMemoryChangeset as IMC

        elif scm_type == 'git':

            from rhodecode.lib.vcs.backends.git import \

                GitInMemoryChangeset as IMC

        return IMC

    def pull_changes(self, repo, username):

        dbrepo = self.__get_repo(repo)

        clone_uri = dbrepo.clone_uri

        if not clone_uri:

            raise Exception("This repository doesn't have a clone uri")

        repo = dbrepo.scm_instance

        repo_name = dbrepo.repo_name

        try:

            if repo.alias == 'git':

                repo.fetch(clone_uri)

            else:

                repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, author, message,

                      content, f_path):

        """

        Commits changes

        :param repo: SCM instance

        """

        user = self._get_user(user)

        IMC = self._get_IMC_module(repo.alias)

        # 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)

        # message and author needs to be unicode

        # proper backend should then translate that into required type

        message = safe_unicode(message)

        author = safe_unicode(author)

                       author=author,

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

        self.mark_for_invalidation(repo_name)

        self._handle_push(repo,

                          username=user.username,

                          action='push_local',

                          repo_name=repo_name,

                          revisions=[tip.raw_id])

        return tip

    def create_node(self, repo, repo_name, cs, user, author, message, content,

                      f_path):

        user = self._get_user(user)

        IMC = self._get_IMC_module(repo.alias)

        # decoding here will force that we have proper encoded values

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

        if isinstance(content, (basestring,)):

            content = safe_str(content)

        elif isinstance(content, (file, cStringIO.OutputType,)):

            content = content.read()

        else:

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

                type(content)

            ))

        message = safe_unicode(message)

        author = safe_unicode(author)

        path = safe_str(f_path)

        m = IMC(repo)

        if isinstance(cs, EmptyChangeset):

            # EmptyChangeset means we we're editing empty repository

            parents = None

        else:

            parents = [cs]

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

        tip = m.commit(message=message,

                       author=author,

                       parents=parents, branch=cs.branch)

        self.mark_for_invalidation(repo_name)

        self._handle_push(repo,

                          username=user.username,

                          action='push_local',

                          repo_name=repo_name,

                          revisions=[tip.raw_id])

        return tip

    def get_nodes(self, repo_name, revision, root_path='/', flat=True):

        """

        recursive walk in root dir and return a set of all path in that dir

        based on repository walk function

        :param repo_name: name of repository

        :param revision: revision for which to list nodes

        :param root_path: root path to list

        :param flat: return as a list, if False returns a dict with decription

        """

        _files = list()

        _dirs = list()

        try:

            _repo = self.__get_repo(repo_name)

            changeset = _repo.scm_instance.get_changeset(revision)

            root_path = root_path.lstrip('/')

            for topnode, dirs, files in changeset.walk(root_path):

                for f in files:

                    _files.append(f.path if flat else {"name": f.path,

                                                       "type": "file"})

                for d in dirs:

                    _dirs.append(d.path if flat else {"name": d.path,

                                                      "type": "dir"})

        except RepositoryError:

            log.debug(traceback.format_exc())

            raise

        return _dirs, _files

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

    def get_repo_landing_revs(self, repo=None):

        """

        Generates select option with tags branches and bookmarks (for hg only)

        grouped by type

        :param repo:

        :type repo:

        """

        hist_l = []

        choices = []

        repo = self.__get_repo(repo)

        hist_l.append(['tip', _('latest tip')])

        choices.append('tip')

        if not repo:

            return choices, hist_l

        repo = repo.scm_instance

        branches_group = ([(k, k) for k, v in

                           repo.branches.iteritems()], _("Branches"))

        hist_l.append(branches_group)

        choices.extend([x[0] for x in branches_group[0]])

        if repo.alias == 'hg':

            bookmarks_group = ([(k, k) for k, v in

                                repo.bookmarks.iteritems()], _("Bookmarks"))

            hist_l.append(bookmarks_group)

            choices.extend([x[0] for x in bookmarks_group[0]])

        tags_group = ([(k, k) for k, v in

                       repo.tags.iteritems()], _("Tags"))

        hist_l.append(tags_group)

        choices.extend([x[0] for x in tags_group[0]])

        return choices, hist_l

    def install_git_hook(self, repo, force_create=False):

        """

        Creates a rhodecode hook inside a git repository

        :param repo: Instance of VCS repo

        :param force_create: Create even if same name hook exists

        """

        loc = jn(repo.path, 'hooks')

        if not repo.bare:

            loc = jn(repo.path, '.git', 'hooks')

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl_post = pkg_resources.resource_string(

            'rhodecode', jn('config', 'post_receive_tmpl.py')

        )

        tmpl_pre = pkg_resources.resource_string(

            'rhodecode', jn('config', 'pre_receive_tmpl.py')

        )

        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:

            _hook_file = jn(loc, '%s-receive' % h_type)

            _rhodecode_hook = False

            log.debug('Installing git hook in repo %s' % repo)

            if os.path.exists(_hook_file):

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

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

                _HOOK_VER_PAT = re.compile(r'^RC_HOOK_VER')

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

                    data = f.read()

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

                                         % 'RC_HOOK_VER').search(data)

                    if matches:

                        try:

                            ver = matches.groups()[0]

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

                            _rhodecode_hook = True

                        except Exception:

                            log.error(traceback.format_exc())

            else:

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

                _rhodecode_hook = True

            if _rhodecode_hook or force_create:

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

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

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

                    f.write(tmpl)

                os.chmod(_hook_file, 0755)

            else:

                log.debug('skipping writing hook file')