def is_root(self):

        """

        Returns ``True`` if node is a root node and ``False`` otherwise.

        """

        return self.kind == NodeKind.DIR and self.path == ''

    def is_submodule(self):

        """

        Returns ``True`` if node's kind is ``NodeKind.SUBMODULE``, ``False``

        otherwise.

        """

        return self.kind == NodeKind.SUBMODULE

    @LazyProperty

    def added(self):

        return self.state is NodeState.ADDED

    @LazyProperty

    def changed(self):

        return self.state is NodeState.CHANGED

    @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 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

        if not isinstance(content, bytes) and content is not None:

            # File content is one thing that inherently must be bytes ... but

            # VCS module tries to be "user friendly" and support unicode ...

            content = safe_bytes(content)

        self._content = content

        self._mode = mode or 0o100644

    def __eq__(self, other):

        eq = super(FileNode, self).__eq__(other)

        if eq is not None:

            return eq

        return self.content == other.content

    def __lt__(self, other):

        lt = super(FileNode, self).__lt__(other)

        if lt is not None:

            return lt

        return self.content < other.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

    @property

    def content(self):

        """

        Returns lazily byte content of the FileNode.

        """

        if self.changeset:

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

        else:

            content = self._content

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

        """

        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

                # try with pygments

                try:

                    mt = lexers.get_lexer_for_filename(self.name).mimetypes

                except lexers.ClassNotFound:

                    mt = None

                if mt:

                    mtype = mt[0]

        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, safe_str(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

        """