``revisions``.

        :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

        """

        self.check_integrity(parents)

        from .repository import GitRepository

        if branch is None:

            branch = GitRepository.DEFAULT_BRANCH_NAME

        repo = self.repository._repo

        object_store = repo.object_store

        ENCODING = "UTF-8"

        DIRMOD = 040000

        # Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or\

            objects.Tree()

        for node in self.added + self.changed:

            # Compute subdirs if needed

            dirpath, nodename = posixpath.split(node.path)

            dirnames = dirpath and dirpath.split('/') or []

            parent = commit_tree

            ancestors = [('', parent)]

            # Tries to dig for the deepest existing tree

            while dirnames:

                curdir = dirnames.pop(0)

                try:

                    dir_id = parent[curdir][1]

                except KeyError:

                    # put curdir back into dirnames and stops

                    dirnames.insert(0, curdir)

                    break

                else:

                    # If found, updates parent

                    parent = self.repository._repo[dir_id]

                    ancestors.append((curdir, parent))

            # for dirnames (in reverse order) [this only applies for nodes from added]

            new_trees = []

            node_path = node.name.encode(ENCODING)

            if dirnames:

                # If there are trees which should be created we need to build

                # them now (in reverse order)

                reversed_dirnames = list(reversed(dirnames))

                curtree = objects.Tree()

                curtree[node_path] = node.mode, blob.id

                new_trees.append(curtree)

                for dirname in reversed_dirnames[:-1]:

                    newtree = objects.Tree()

                    #newtree.add(DIRMOD, dirname, curtree.id)

                    newtree[dirname] = DIRMOD, curtree.id

                    new_trees.append(newtree)

                    curtree = newtree

                parent[reversed_dirnames[-1]] = DIRMOD, curtree.id

            else:

                parent.add(name=node_path, mode=node.mode, hexsha=blob.id)

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

                zip(ancestors, ancestors[1:])]):

                parent[path] = DIRMOD, tree.id

                object_store.add_object(tree)

            object_store.add_object(blob)

            for tree in new_trees:

                object_store.add_object(tree)

        for node in self.removed:

            paths = node.path.split('/')

            tree = commit_tree

            trees = [tree]

            # Traverse deep into the forest...

            for path in paths:

                try:

                    obj = self.repository._repo[tree[path][1]]

                    if isinstance(obj, objects.Tree):

                        trees.append(obj)

                        tree = obj

                except KeyError:

                    break

            # Cut down the blob and all rotten trees on the way back...

            for path, tree in reversed(zip(paths, trees)):

                del tree[path]

                if tree:

                    # This tree still has elements - don't remove it or any

                    # of it's parents

                    break

"""

Tests so called "in memory changesets" commit API of vcs.

"""

from __future__ import with_statement

from rhodecode.lib import vcs

import time

import datetime

from conf import SCM_TESTS, get_new_dir

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.exceptions import NodeAlreadyAddedError

from rhodecode.lib.vcs.exceptions import NodeAlreadyExistsError

from rhodecode.lib.vcs.exceptions import NodeAlreadyRemovedError

from rhodecode.lib.vcs.exceptions import NodeAlreadyChangedError

from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError

from rhodecode.lib.vcs.exceptions import NodeNotChangedError

from rhodecode.lib.vcs.nodes import DirNode

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.lib.vcs.utils.compat import unittest

class InMemoryChangesetTestMixin(object):

    """

    This is a backend independent test case class which should be created

    with ``type`` method.

    It is required to set following attributes at subclass:

    - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)

    - ``repo_path``: path to the repository which would be created for set of

      tests

    """

    def get_backend(self):

        return vcs.get_backend(self.backend_alias)

    def setUp(self):

        Backend = self.get_backend()

        self.repo_path = get_new_dir(str(time.time()))

        self.repo = Backend(self.repo_path, create=True)

        self.imc = self.repo.in_memory_changeset

        self.nodes = [

            FileNode('foobar', content='Foo & bar'),

            FileNode('foobar2', content='Foo & bar, doubled!'),

            FileNode('foo bar with spaces', content=''),

            FileNode('foo/bar/baz', content='Inside'),

        ]

    def test_add(self):

        rev_count = len(self.repo.revisions)

        to_add = [FileNode(node.path, content=node.content)

            for node in self.nodes]

        for node in to_add:

            self.imc.add(node)

        message = u'Added: %s' % ', '.join((node.path for node in self.nodes))

        author = unicode(self.__class__)

        changeset = self.imc.commit(message=message, author=author)

        newtip = self.repo.get_changeset()

        self.assertEqual(changeset, newtip)

        self.assertEqual(rev_count + 1, len(self.repo.revisions))

        self.assertEqual(newtip.message, message)

        self.assertEqual(newtip.author, author)

        self.assertTrue(not any((self.imc.added, self.imc.changed,

            self.imc.removed)))

        for node in to_add:

            self.assertEqual(newtip.get_node(node.path).content, node.content)

    def test_add_in_bulk(self):

        rev_count = len(self.repo.revisions)

        to_add = [FileNode(node.path, content=node.content)

            for node in self.nodes]

        self.imc.add(*to_add)

        message = u'Added: %s' % ', '.join((node.path for node in self.nodes))

        author = unicode(self.__class__)

        changeset = self.imc.commit(message=message, author=author)

        newtip = self.repo.get_changeset()

        self.assertEqual(changeset, newtip)

        self.assertEqual(rev_count + 1, len(self.repo.revisions))

        self.assertEqual(newtip.message, message)

        self.assertEqual(newtip.author, author)

        self.assertTrue(not any((self.imc.added, self.imc.changed,

            self.imc.removed)))

        for node in to_add:

            self.assertEqual(newtip.get_node(node.path).content, node.content)

    def test_add_actually_adds_all_nodes_at_second_commit_too(self):

        self.imc.add(FileNode('foo/bar/image.png', content='\0'))

        self.imc.add(FileNode('foo/README.txt', content='readme!'))

        changeset = self.imc.commit(u'Initial', u'joe.doe@example.com')

        self.assertTrue(isinstance(changeset.get_node('foo'), DirNode))

        self.assertTrue(isinstance(changeset.get_node('foo/bar'), DirNode))

        self.assertEqual(changeset.get_node('foo/bar/image.png').content, '\0')