kallithea Changeset - 9757ad98ea09

Changeset - 9757ad98ea09

Parent rev.

Child rev.

[Not reviewed]

default

0 2 0

Mads Kiilerich - 6 years ago 2020-03-28 21:07:08
mads@kiilerich.com

Grafted from: a234de987f8e

vcs: simplify nodes kind handling

Avoid pytype's very reasonable confusion over the _kind handling.

Node.kind is actually only ever set in __init__, so there is not much need for
a paranoid setter.

2 files changed with 5 insertions and 24 deletions:

kallithea/lib/vcs/nodes.py

kallithea/tests/vcs/test_nodes.py

0 comments (0 inline, 0 general)

kallithea/lib/vcs/nodes.py

➞

Show inline comments

@@ @@ -35,225 +35,211 @@ class NodeState: @@
 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 __getitem__(self, key):
         assert isinstance(key, slice), key
         for p in self.current_paths[key]:
             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 __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 _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 __eq__(self, other):
         if type(self) is not type(other):
             return False
-        if self._kind != other._kind:
+        if self.kind != other.kind:
             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):
-        if self._kind < other._kind:
+        if self.kind < other.kind:
             return True
-        if self._kind > other._kind:
+        if self.kind > other.kind:
             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.
         """
         return self.kind == NodeKind.SUBMODULE
     @LazyProperty
     def added(self):
         return self.state is NodeState.ADDED
     @LazyProperty
     def changed(self):
         return self.state is NodeState.CHANGED
     @LazyProperty
     def not_changed(self):
         return self.state is NodeState.NOT_CHANGED
     @LazyProperty
     def removed(self):
         return self.state is NodeState.REMOVED
 class FileNode(Node):
     """
     Class representing file nodes.
     :attribute: path: path to the node, relative to repository's root
     :attribute: content: if given arbitrary sets content of the file
     :attribute: changeset: if given, first time content is accessed, callback
     :attribute: mode: octal stat mode for a node. Default is 0100644.
     """
     def __init__(self, path, content=None, changeset=None, mode=None):
         """
         Only one of ``content`` and ``changeset`` may be given. Passing both
         would raise ``NodeError`` exception.
         :param path: relative path to the node
         :param content: content may be passed to constructor
         :param changeset: if given, will use it to lazily fetch content
         :param mode: octal representation of ST_MODE (i.e. 0100644)
         """
         if content and changeset:
             raise NodeError("Cannot use both content and changeset")
         super(FileNode, self).__init__(path, kind=NodeKind.FILE)
         self.changeset = changeset
         if not isinstance(content, bytes) and content is not None:
             # File content is one thing that inherently must be bytes ... but
             # VCS module tries to be "user friendly" and support unicode ...
@@ @@ -494,116 +480,116 @@ class DirNode(Node): @@
         return sorted(nodes)
     @LazyProperty
     def files(self):
         return sorted((node for node in self.nodes if node.is_file()))
     @LazyProperty
     def dirs(self):
         return sorted((node for node in self.nodes if node.is_dir()))
     def __iter__(self):
         for node in self.nodes:
             yield node
     def get_node(self, path):
         """
         Returns node from within this particular ``DirNode``, so it is now
         allowed to fetch, i.e. node located at 'docs/api/index.rst' from node
         'docs'. In order to access deeper nodes one must fetch nodes between
         them first - this would work::
            docs = root.get_node('docs')
            docs.get_node('api').get_node('index.rst')
         :param: path - relative to the current node
         .. note::
            To access lazily (as in example above) node have to be initialized
            with related changeset object - without it node is out of
            context and may know nothing about anything else than nearest
            (located at same level) nodes.
         """
         try:
             path = path.rstrip('/')
             if path == '':
                 raise NodeError("Cannot retrieve node without path")
             self.nodes  # access nodes first in order to set _nodes_dict
             paths = path.split('/')
             if len(paths) == 1:
                 if not self.is_root():
                     path = '/'.join((self.path, paths[0]))
                 else:
                     path = paths[0]
                 return self._nodes_dict[path]
             elif len(paths) > 1:
                 if self.changeset is None:
                     raise NodeError("Cannot access deeper "
                                     "nodes without changeset")
                 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.path = name
+        self.path = name.rstrip('/')
         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)

kallithea/tests/vcs/test_nodes.py

➞

Show inline comments

 import mimetypes
 import stat
 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_kind_setter(self):
         node = Node('', NodeKind.DIR)
         with pytest.raises(NodeError):
             setattr(node, 'kind', 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()
-        with pytest.raises(NodeError):
+        with pytest.raises(AttributeError):  # Note: this used to raise NodeError
             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
     def test_mimetype(self):
         py_node = FileNode('test.py')
         tar_node = FileNode('test.tar.gz')
         my_node2 = FileNode('myfile2')
         my_node2._content = b'foobar'
         my_node3 = FileNode('myfile3')
         my_node3._content = b'\0foobar'
         assert py_node.mimetype == mimetypes.guess_type(py_node.name)[0]
         assert py_node.get_mimetype() == mimetypes.guess_type(py_node.name)
         assert tar_node.mimetype == mimetypes.guess_type(tar_node.name)[0]
         assert tar_node.get_mimetype() == mimetypes.guess_type(tar_node.name)
         assert my_node2.mimetype == 'text/plain'
         assert my_node2.get_mimetype() == ('text/plain', None)
         assert my_node3.mimetype == 'application/octet-stream'
         assert my_node3.get_mimetype() == ('application/octet-stream', None)
 class TestNodeContent(object):
     def test_if_binary(self):
         data = """\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f??a\x00\x00\x00\x04gAMA\x00\x00\xaf?7\x05\x8a?\x00\x00\x00\x19tEXtSoftware\x00Adobe ImageReadyq?e<\x00\x00\x025IDAT8?\xa5\x93?K\x94Q\x14\x87\x9f\xf7?Q\x1bs4?\x03\x9a\xa8?B\x02\x8b$\x10[U;i\x13?6h?&h[?"\x14j?\xa2M\x7fB\x14F\x9aQ?&\x842?\x0b\x89"\x82??!?\x9c!\x9c2l??{N\x8bW\x9dY\xb4\t/\x1c?=\x9b?}????\xa9*;9!?\x83\x91?[?\\v*?D\x04\'`EpNp\xa2X\'U?pVq"Sw.\x1e?\x08\x01D?jw????\xbc??7{|\x9b?\x89$\x01??W@\x15\x9c\x05q`Lt/\x97?\x94\xa1d?\x18~?\x18?\x18W[%\xb0?\x83??\x14\x88\x8dB?\xa6H\tL\tl\x19>/\x01`\xac\xabx?\x9cl\nx\xb0\x98\x07\x95\x88D$"q[\x19?d\x00(o\n\xa0??\x7f\xb9\xa4?\x1bF\x1f\x8e\xac\xa8?j??eUU}?.?\x9f\x8cE??x\x94??\r\xbdtoJU5"0N\x10U?\x00??V\t\x02\x9f\x81?U?\x00\x9eM\xae2?r\x9b7\x83\x82\x8aP3????.?&"?\xb7ZP \x0c<?O\xa5\t}\xb8?\x99\xa6?\x87?\x1di|/\xa0??0\xbe\x1fp?d&\x1a\xad\x95\x8a\x07?\t*\x10??b:?d?.\x13C\x8a?\x12\xbe\xbf\x8e?{???\x08?\x80\xa7\x13+d\x13>J?\x80\x15T\x95\x9a\x00??S\x8c\r?\xa1\x03\x07?\x96\x9b\xa7\xab=E??\xa4\xb3?\x19q??B\x91=\x8d??k?J\x0bV"??\xf7x?\xa1\x00?\\.\x87\x87???\x02F@D\x99],??\x10#?X\xb7=\xb9\x10?Z\x1by???cI??\x1ag?\x92\xbc?T?t[\x92\x81?<_\x17~\x92\x88?H%?\x10Q\x02\x9f\n\x81qQ\x0bm?\x1bX?\xb1AK\xa6\x9e\xb9?u\xb2?1\xbe|/\x92M@\xa2!F?\xa9>"\r<DT?>\x92\x8e?>\x9a9Qv\x127?a\xac?Y?8?:??]X???9\x80\xb7?u?\x0b#BZ\x8d=\x1d?p\x00\x00\x00\x00IEND\xaeB`\x82"""
         filenode = FileNode('calendar.png', content=data)
         assert filenode.is_binary
     def test_if_binary_empty(self):
         empty_cs = EmptyChangeset()
         filenode = FileNode('foo', changeset=empty_cs)
         assert not filenode.is_binary

0 comments (0 inline, 0 general)