def __getitem__(self, key):

        assert isinstance(key, slice), key

        for p in self.current_paths[key]:

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

        """

        Returns name of the node so if its path

        then only last part is returned.

        """

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

    def __eq__(self, other):

        if type(self) is not type(other):

            return False

            return False

        if self.path != other.path:

            return False

        if self.is_file():

            return self.content == other.content

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

            return self_nodes_paths == other_nodes_paths

    def __lt__(self, other):

            return True

            return False

        if self.path < other.path:

            return True

        if self.path > other.path:

            return False

        if self.is_file():

            return self.content < other.content

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

            return self_nodes_paths < other_nodes_paths

    def __repr__(self):

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

    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 == ''

    def is_submodule(self):

        """

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

        otherwise.

                else:

                    path1, path2 = paths[0], '/'.join(paths[1:])

                    return self.get_node(path1).get_node(path2)

            else:

                raise KeyError

        except KeyError:

            raise NodeError("Node does not exist at %s" % path)

    @LazyProperty

    def state(self):

        raise NodeError("Cannot access state of DirNode")

    @LazyProperty

    def size(self):

        size = 0

        for root, dirs, files in self.changeset.walk(self.path):

            for f in files:

                size += f.size

        return size

    def __repr__(self):

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

                                 getattr(self.changeset, 'short_id', ''))

class RootNode(DirNode):

    """

    DirNode being the root node of the repository.

    """

    def __init__(self, nodes=(), changeset=None):

        super(RootNode, self).__init__(path='', nodes=nodes,

            changeset=changeset)

    def __repr__(self):

        return '<%s>' % self.__class__.__name__

class SubModuleNode(Node):

    """

    represents a SubModule of Git or SubRepo of Mercurial

    """

    is_binary = False

    size = 0

    def __init__(self, name, url, changeset=None, alias=None):

        # Note: Doesn't call Node.__init__!

        self.kind = NodeKind.SUBMODULE

        self.alias = alias

        # we have to use emptyChangeset here since this can point to svn/git/hg

        # submodules we cannot get from repository

        self.changeset = EmptyChangeset(changeset, alias=alias)

        self.url = url

    def __repr__(self):

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

                                 getattr(self.changeset, 'short_id', ''))

    @LazyProperty

    def name(self):

        """

        Returns name of the node so if its path

        then only last part is returned.

        """

        org = self.path.rstrip('/').rsplit('/', 1)[-1]

        return '%s @ %s' % (org, self.changeset.short_id)

import pytest

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

from kallithea.lib.vcs.nodes import DirNode, FileNode, Node, NodeError, NodeKind

class TestNodeBasic(object):

    def test_init(self):

        """

        Cannot initialize Node objects with path with slash at the beginning.

        """

        wrong_paths = (

            '/foo',

            '/foo/bar'

        )

        for path in wrong_paths:

            with pytest.raises(NodeError):

                Node(path, NodeKind.FILE)

        wrong_paths = (

            '/foo/',

            '/foo/bar/'

        )

        for path in wrong_paths:

            with pytest.raises(NodeError):

                Node(path, NodeKind.DIR)

    def test_name(self):

        node = Node('', NodeKind.DIR)

        assert node.name == ''

        node = Node('path', NodeKind.FILE)

        assert node.name == 'path'

        node = Node('path/', NodeKind.DIR)

        assert node.name == 'path'

        node = Node('some/path', NodeKind.FILE)

        assert node.name == 'path'

        node = Node('some/path/', NodeKind.DIR)

        assert node.name == 'path'

    def test_root_node(self):

        with pytest.raises(NodeError):

            Node('', NodeKind.FILE)

    def _test_parent_path(self, node_path, expected_parent_path):

        """

        Tests if node's parent path are properly computed.

        """

        node = Node(node_path, NodeKind.DIR)

        parent_path = node.get_parent_path()

        assert parent_path.endswith('/') or node.is_root() and parent_path == ''

        assert parent_path == expected_parent_path, \

            "Node's path is %r and parent path is %r but should be %r" \

            % (node.path, parent_path, expected_parent_path)

    def test_parent_path(self):

        test_paths = (

            # (node_path, expected_parent_path)

            ('', ''),

            ('some/path/', 'some/'),

            ('some/longer/path/', 'some/longer/'),

        )

        for node_path, expected_parent_path in test_paths:

            self._test_parent_path(node_path, expected_parent_path)

    '''

    def _test_trailing_slash(self, path):

        if not path.endswith('/'):

            pytest.fail("Trailing slash tests needs paths to end with slash")

        for kind in NodeKind.FILE, NodeKind.DIR:

            with pytest.raises(NodeError):

                Node(path=path, kind=kind)

    def test_trailing_slash(self):

        for path in ('/', 'foo/', 'foo/bar/', 'foo/bar/biz/'):

            self._test_trailing_slash(path)

    '''

    def test_is_file(self):

        node = Node('any', NodeKind.FILE)

        assert node.is_file()

        node = FileNode('any')

        assert node.is_file()

        with pytest.raises(AttributeError):

            getattr(node, 'nodes')

    def test_is_dir(self):

        node = Node('any_dir', NodeKind.DIR)

        assert node.is_dir()

        node = DirNode('any_dir')

        assert node.is_dir()

            getattr(node, 'content')

    def test_dir_node_iter(self):

        nodes = [

            DirNode('docs'),

            DirNode('tests'),

            FileNode('bar'),

            FileNode('foo'),

            FileNode('readme.txt'),

            FileNode('setup.py'),

        ]

        dirnode = DirNode('', nodes=nodes)

        for node in dirnode:

            node == dirnode.get_node(node.path)

    def test_node_state(self):

        """

        Without link to changeset nodes should raise NodeError.

        """

        node = FileNode('anything')

        with pytest.raises(NodeError):

            getattr(node, 'state')

        node = DirNode('anything')

        with pytest.raises(NodeError):

            getattr(node, 'state')

    def test_file_node_stat(self):

        node = FileNode('foobar', 'empty... almost')

        mode = node.mode  # default should be 0100644

        assert mode & stat.S_IRUSR

        assert mode & stat.S_IWUSR

        assert mode & stat.S_IRGRP

        assert mode & stat.S_IROTH

        assert not mode & stat.S_IWGRP

        assert not mode & stat.S_IWOTH

        assert not mode & stat.S_IXUSR

        assert not mode & stat.S_IXGRP

        assert not mode & stat.S_IXOTH

    def test_file_node_is_executable(self):

        node = FileNode('foobar', 'empty... almost', mode=0o100755)

        assert node.is_executable

        node = FileNode('foobar', 'empty... almost', mode=0o100500)

        assert node.is_executable

        node = FileNode('foobar', 'empty... almost', mode=0o100644)

        assert not node.is_executable