self.added = []

        self.changed = []

        self.removed = []

        self.parents = []

    def add(self, *filenodes):

        """

        Marks given ``FileNode`` objects as *to be committed*.

        :raises ``NodeAlreadyExistsError``: if node with same path exists at

          latest changeset

        :raises ``NodeAlreadyAddedError``: if node with same path is already

          marked as *added*

        """

        # Check if not already marked as *added* first

        for node in filenodes:

            if node.path in (n.path for n in self.added):

                raise NodeAlreadyAddedError("Such FileNode %s is already "

                    "marked for addition" % node.path)

        for node in filenodes:

            self.added.append(node)

    def change(self, *filenodes):

        """

        Marks given ``FileNode`` objects to be *changed* in next commit.

        :raises ``EmptyRepositoryError``: if there are no changesets yet

        :raises ``NodeAlreadyExistsError``: if node with same path is already

          marked to be *changed*

        :raises ``NodeAlreadyRemovedError``: if node with same path is already

          marked to be *removed*

        :raises ``NodeDoesNotExistError``: if node doesn't exist in latest

          changeset

        :raises ``NodeNotChangedError``: if node hasn't really be changed

        """

        for node in filenodes:

            if node.path in (n.path for n in self.removed):

                raise NodeAlreadyRemovedError("Node at %s is already marked "

                    "as removed" % node.path)

        try:

            self.repository.get_changeset()

        except EmptyRepositoryError:

            raise EmptyRepositoryError("Nothing to change - try to *add* new "

                "nodes rather than changing them")

        for node in filenodes:

            if node.path in (n.path for n in self.changed):

                raise NodeAlreadyChangedError("Node at '%s' is already "

                    "marked as changed" % node.path)

            self.changed.append(node)

    def remove(self, *filenodes):

        """

        Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be

        *removed* in next commit.

        :raises ``NodeAlreadyRemovedError``: if node has been already marked to

          be *removed*

        :raises ``NodeAlreadyChangedError``: if node has been already marked to

          be *changed*

        """

        for node in filenodes:

            if node.path in (n.path for n in self.removed):

                raise NodeAlreadyRemovedError("Node is already marked to "

                    "for removal at %s" % node.path)

            if node.path in (n.path for n in self.changed):

                raise NodeAlreadyChangedError("Node is already marked to "

                    "be changed at %s" % node.path)

            # We only mark node as *removed* - real removal is done by

            # commit method

            self.removed.append(node)

    def reset(self):

        """

        Resets this instance to initial state (cleans ``added``, ``changed``

        and ``removed`` lists).

        """

        self.added = []

        self.changed = []

        self.removed = []

        self.parents = []

    def get_ipaths(self):

        """

        Returns generator of paths from nodes marked as added, changed or

        removed.

        """

        for node in chain(self.added, self.changed, self.removed):

            yield node.path

    def get_paths(self):

        """

        Returns list of paths from nodes marked as added, changed or removed.

        """

        return list(self.get_ipaths())

    def check_integrity(self, parents=None):

        """

        Checks in-memory changeset's integrity. Also, sets parents if not

        already set.

        :raises CommitError: if any error occurs (i.e.

          ``NodeDoesNotExistError``).

        """

        if not self.parents:

            parents = parents or []

            if len(parents) == 0:

                try:

                    parents = [self.repository.get_changeset(), None]

                except EmptyRepositoryError:

                    parents = [None, None]

            elif len(parents) == 1:

                parents += [None]

            self.parents = parents

        # Local parents, only if not None

        parents = [p for p in self.parents if p]

        # Check nodes marked as added

        for p in parents:

            for node in self.added:

                try:

                    p.get_node(node.path)

                except NodeDoesNotExistError:

                    pass

                else:

                    raise NodeAlreadyExistsError("Node at %s already exists "

                        "at %s" % (node.path, p))

        # Check nodes marked as changed

        missing = set(self.changed)

        not_changed = set(self.changed)

        if self.changed and not parents:

            raise NodeDoesNotExistError(str(self.changed[0].path))

        for p in parents:

            for node in self.changed:

                try:

                    old = p.get_node(node.path)

                    missing.remove(node)

                    if old.content != node.content:

                        not_changed.remove(node)

                except NodeDoesNotExistError:

                    pass

        if self.changed and missing:

            raise NodeDoesNotExistError("Node at %s is missing "

                "(parents: %s)" % (node.path, parents))

        if self.changed and not_changed:

            raise NodeNotChangedError("Node at %s wasn't actually changed "

                "since parents' changesets: %s" % (not_changed.pop().path,

                    parents)

            )

        # Check nodes marked as removed

        if self.removed and not parents:

            raise NodeDoesNotExistError("Cannot remove node at %s as there "

                "were no parents specified" % self.removed[0].path)

        really_removed = set()

        for p in parents:

            for node in self.removed:

                try:

                    p.get_node(node.path)

                    really_removed.add(node)

                except ChangesetError:

                    pass

        not_removed = set(self.removed) - really_removed

        if not_removed:

            raise NodeDoesNotExistError("Cannot remove node at %s from "

                "following parents: %s" % (not_removed[0], parents))

    def commit(self, message, author, parents=None, branch=None, date=None,

            **kwargs):

        """

        Performs in-memory commit (doesn't check workdir in any way) and

        returns newly created ``Changeset``. Updates repository's

        ``revisions``.

        .. note::

            While overriding this method each backend's should call

            ``self.check_integrity(parents)`` in the first place.

        :param message: message of the commit

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

        :param parents: single parent or sequence of parents from which commit

          would be derieved

        :param date: ``datetime.datetime`` instance. Defaults to

          ``datetime.datetime.now()``.

        :param branch: branch name, as string. If none given, default backend's

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        raise NotImplementedError

# -*- coding: utf-8 -*-

"""

    vcs.nodes

    ~~~~~~~~~

    Module holding everything related to vcs nodes.

    :created_on: Apr 8, 2010

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

"""

import os

import stat

import posixpath

import mimetypes

from pygments import lexers

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

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

from rhodecode.lib.vcs.exceptions import NodeError

from rhodecode.lib.vcs.exceptions import RemovedFileNodeError

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]

    def __getslice__(self, i, j):

        for p in self.current_paths[i:j]:

            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)

    def __getslice__(self, i, j):

        for p in self.current_paths[i:j]:

            yield RemovedFileNode(path=p)

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 = path.rstrip('/')

        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 unicode_path(self):

        return safe_unicode(self.path)

    @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

    def _set_kind(self, kind):

        if hasattr(self, '_kind'):

            raise NodeError("Cannot change node's kind")

        else:

            self._kind = kind

            # Post setter check (path's trailing slash)

            if self.path.endswith('/'):

                raise NodeError("Node's path cannot end with slash")

    kind = property(_get_kind, _set_kind)

    def __cmp__(self, other):

        """

        Comparator using name of the node, needed for quick list sorting.

        """

        kind_cmp = cmp(self.kind, other.kind)

        if kind_cmp:

            return kind_cmp

        return cmp(self.name, other.name)

    def __eq__(self, other):

        for attr in ['name', 'path', 'kind']:

            if getattr(self, attr) != getattr(other, attr):

                return False

        if self.is_file():

            if self.content != other.content:

                return False

        else:

            # For DirNode's check without entering each dir

            self_nodes_paths = list(sorted(n.path for n in self.nodes))

            other_nodes_paths = list(sorted(n.path for n in self.nodes))

            if self_nodes_paths != other_nodes_paths:

                return False

        return True

    def __nq__(self, other):

        return not self.__eq__(other)

    def __repr__(self):

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

    def __str__(self):

        return self.__repr__()

    def __unicode__(self):

        return self.name

    def get_parent_path(self):

        """

        Returns node's parent path or empty string if node is root.

        """

        if self.is_root():

            return ''

        return posixpath.dirname(self.path.rstrip('/')) + '/'

    def is_file(self):

        """

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

        otherwise.

        """

        return self.kind == NodeKind.FILE

    def is_dir(self):

        """

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

        otherwise.

        """

        return self.kind == NodeKind.DIR

    def is_root(self):

        """

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

        """

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