"""

        if path.endswith('/'):

            path = path.rstrip('/')

        return path

    def _get_id_for_path(self, path):

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if not path in self._paths:

            path = path.strip('/')

            # set root tree

            tree = self.repository._repo[self._tree_id]

            if path == '':

                        name = item

                    self._paths[name] = id

                    self._stat_modes[name] = stat

            if not path in self._paths:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path '%s' at revision %s"

        return self._paths[path]

    def _get_kind(self, path):

        obj = self.repository._repo[self._get_id_for_path(path)]

        if isinstance(obj, objects.Blob):

            return NodeKind.FILE

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        # ensure path is traversed

        self._get_id_for_path(path)

        return self._stat_modes[path]

    def get_file_content(self, path):

        """

        Returns content of the file at given ``path``.

        # 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)

            parent = commit_tree

            ancestors = [('', parent)]

            # Tries to dig for the deepest existing tree

            while dirnames:

                curdir = dirnames.pop(0)

import posixpath

import mimetypes

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

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

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

class NodeKind:

    SUBMODULE = -1

    DIR = 1

    FILE = 2

    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 "

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

        processed_nodes = []

        for f_path in nodes:

            if f_path.startswith('/') or f_path.startswith('.') or '../' in f_path:

                raise NonRelativePathError('%s is not an relative path' % f_path)

            if f_path:

                f_path = os.path.normpath(f_path)

            f_path = safe_str(f_path)

            # decoding here will force that we have proper encoded values

            # in any other case this will throw exceptions and deny commit

            if isinstance(content, (basestring,)):

                content = safe_str(content)

            elif isinstance(content, (file, cStringIO.OutputType,)):

                content = content.read()

from __future__ import with_statement

import time

import datetime

from rhodecode.lib import vcs

from rhodecode.tests.vcs.base import BackendTestMixin

            {

                'message': u'Initial',

                'author': u'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

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

                    FileNode('foobar', content='foo'),

                    FileNode('qwe', content='foo'),

                ],

            },

            {

                'message': u'Massive changes',

        ]

    def test_initial_commit(self):

        changeset = self.repo.get_changeset(0)

        self.assertItemsEqual(changeset.added, [

            changeset.get_node('foo/bar'),

            changeset.get_node('foobar'),

            changeset.get_node('qwe'),

        ])

        self.assertItemsEqual(changeset.changed, [])

        self.assertItemsEqual(changeset.removed, [])

            changeset.get_node('foobar'),

        ])

        self.assertTrue(isinstance(changeset.removed, RemovedFileNodesGenerator))

        self.assertEqual(len(changeset.removed), 1)

        self.assertEqual(list(changeset.removed)[0].path, 'qwe')

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

"""

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

"""

from __future__ import with_statement

import time

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.

        self.assertEqual(changeset.get_node('foo/bar/foobaz/bar').content, 'foo')

        self.assertEqual(changeset.get_node('foo/bar/another/bar').content, 'foo')

        self.assertEqual(changeset.get_node('foo/baz.txt').content, 'foo')

        self.assertEqual(changeset.get_node('foobar/foobaz/file').content, 'foo')

        self.assertEqual(changeset.get_node('foobar/barbaz').content, 'foo')

    def test_add_raise_already_added(self):

        node = FileNode('foobar', content='baz')

        self.imc.add(node)

        self.assertRaises(NodeAlreadyAddedError, self.imc.add, node)

    def test_check_integrity_raise_already_exist(self):

        self.imc.commit(u'Changed %s' % node.path, u'joe.doe@example.com')

        newtip = self.repo.get_changeset()

        self.assertNotEqual(tip, newtip)

        self.assertNotEqual(tip.id, newtip.id)

        self.assertEqual(newtip.get_node('foo/bar/baz').content,

    def test_change_raise_empty_repository(self):

        node = FileNode('foobar')

        self.assertRaises(EmptyRepositoryError, self.imc.change, node)

    def test_check_integrity_change_raise_node_does_not_exist(self):