return size

    def is_valid(self):

        """

        Validates repository.

        """

        raise NotImplementedError

    def is_empty(self):

        return self._empty

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

    # CHANGESETS

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

    def get_changeset(self, revision=None):

        """

        Returns instance of ``Changeset`` class. If ``revision`` is None, most

        recent changeset is returned.

        :raises ``EmptyRepositoryError``: if there are no revisions

        """

        raise NotImplementedError

    def __iter__(self):

        """

        Allows Repository objects to be iterated.

        *Requires* implementation of ``__getitem__`` method.

        """

        for revision in self.revisions:

            yield self.get_changeset(revision)

    def get_changesets(self, start=None, end=None, start_date=None,

                       end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns iterator of ``BaseChangeset`` objects from start to end,

        both inclusive.

        :param start: None or str

        :param end: None or str

        :param start_date:

        :param end_date:

        :param branch_name:

        :param reversed:

        """

        raise NotImplementedError

    def __getitem__(self, key):

        return self.get_changeset(key)

    def count(self):

        return len(self.revisions)

    def tag(self, name, user, revision=None, message=None, date=None, **opts):

        """

        Creates and returns a tag for the given ``revision``.

        :param name: name for new tag

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param revision: changeset id for which new tag would be created

        :param message: message of the tag's commit

        :param date: date of tag's commit

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        raise NotImplementedError

    def remove_tag(self, name, user, message=None, date=None):

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param message: message of the tag's removal commit

        :param date: date of tag's removal commit

        :raises TagDoesNotExistError: if tag with given name does not exists

        """

        raise NotImplementedError

    def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,

            context=3):

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

          shown. Defaults to ``3``.

        """

        raise NotImplementedError

    vcs.nodes

    ~~~~~~~~~

    Module holding everything related to vcs nodes.

    :created_on: Apr 8, 2010

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

"""

import functools

import mimetypes

import posixpath

import stat

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import NodeError, RemovedFileNodeError

from kallithea.lib.vcs.utils import safe_str, safe_unicode

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

class NodeKind:

    SUBMODULE = -1

    DIR = 1

    FILE = 2

class NodeState:

    ADDED = u'added'

    CHANGED = u'changed'

    NOT_CHANGED = u'not changed'

    REMOVED = u'removed'

class NodeGeneratorBase(object):

    """

    Base class for removed added and changed filenodes, it's a lazy generator

    class that will create filenodes only on iteration or call

    The len method doesn't need to create filenodes at all

    """

    def __init__(self, current_paths, cs):

        self.cs = cs

        self.current_paths = current_paths

    def __call__(self):

        return [n for n in self]

            yield self.cs.get_node(p)

    def __len__(self):

        return len(self.current_paths)

    def __iter__(self):

        for p in self.current_paths:

            yield self.cs.get_node(p)

class AddedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding Added files for current changeset

    """

    pass

class ChangedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding Changed files for current changeset

    """

    pass

class RemovedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding removed files for current changeset

    """

    def __iter__(self):

        for p in self.current_paths:

            yield RemovedFileNode(path=p)

            yield RemovedFileNode(path=p)

@functools.total_ordering

class Node(object):

    """

    Simplest class representing file or directory on repository.  SCM backends

    should use ``FileNode`` and ``DirNode`` subclasses rather than ``Node``

    directly.

    Node's ``path`` cannot start with slash as we operate on *relative* paths

    only. Moreover, every single node is identified by the ``path`` attribute,

    so it cannot end with slash, too. Otherwise, path could lead to mistakes.

    """

    def __init__(self, path, kind):

        if path.startswith('/'):

            raise NodeError("Cannot initialize Node objects with slash at "

                            "the beginning as only relative paths are supported")

        self.path = safe_str(path.rstrip('/'))  # we store paths as str

        if path == '' and kind != NodeKind.DIR:

            raise NodeError("Only DirNode and its subclasses may be "

                            "initialized with empty path")

        self.kind = kind

        #self.dirs, self.files = [], []

        if self.is_root() and not self.is_dir():

            raise NodeError("Root node cannot be FILE kind")

    @LazyProperty

    def parent(self):

        parent_path = self.get_parent_path()

        if parent_path:

            if self.changeset:

                return self.changeset.get_node(parent_path)

            return DirNode(parent_path)

        return None

    @LazyProperty

    def name(self):

        """

        Returns name of the node so if its path

        then only last part is returned.

        """

        return safe_unicode(self.path.rstrip('/').split('/')[-1])

    def _get_kind(self):

        return self._kind