: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 itertools.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

        if self.changed and not parents:

        for p in parents:

            for node in self.changed:

                try:

                    old = p.get_node(node.path)

                    # if content actually changed, remove node from unchanged

                    if old.content != node.content:

                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 "

                    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)

                except ChangesetError:

                    pass

        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 derived

        :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

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset. It's possible to pass hash when creating

    an EmptyChangeset

    """

    def __init__(self, cs='0' * 40, repo=None, requested_revision=None,

                 alias=None, revision=-1, message='', author='', date=None):

        self._empty_cs = cs

        self.revision = revision

        self.message = message

        self.author = author

        self.date = date or datetime.datetime.fromtimestamp(0)

        self.repository = repo

        self.requested_revision = requested_revision

        self.alias = alias

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifying this changeset, useful for web

        representation.

        """

        return self._empty_cs

    @LazyProperty

    def branch(self):

        from kallithea.lib.vcs.backends import get_backend

        return get_backend(self.alias).DEFAULT_BRANCH_NAME

    @LazyProperty

    def branches(self):

        from kallithea.lib.vcs.backends import get_backend

        return [get_backend(self.alias).DEFAULT_BRANCH_NAME]

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

    def get_file_changeset(self, path):

        return self

    def get_file_content(self, path):

        return u''

    def get_file_size(self, path):

        return 0

class CollectionGenerator(object):

    def __init__(self, repo, revs):

        self.repo = repo

        self.revs = revs

    def __len__(self):

        return len(self.revs)

    def __iter__(self):

        for rev in self.revs:

            yield self.repo.get_changeset(rev)

    def __getitem__(self, what):

        """Return either a single element by index, or a sliced collection."""

        if isinstance(what, slice):

            return CollectionGenerator(self.repo, self.revs[what])