Fix classes for backward compatibility

Signed-off-by: Konstantin Slavnov <[email protected]>

Author: zurk

bblfsh/__init__.py

@@ -2,25 +2,4 @@
 from bblfsh.pyuast import decode, iterator, uast
 from bblfsh.tree_order import TreeOrder
 from bblfsh.aliases import *
-
-
-class RoleSearchException(Exception):
-    pass
-
-
-def role_id(rname: str) -> int:
-    try:
-        name = DESCRIPTOR.enum_types_by_name["Role"].values_by_name[rname].number
-    except KeyError:
-        raise RoleSearchException("Role with name '{}' not found".format(rname))
-
-    return name
-
-
-def role_name(rid: int) -> str:
-    try:
-        id_ = DESCRIPTOR.enum_types_by_name["Role"].values_by_number[rid].name
-    except KeyError:
-        raise RoleSearchException("Role with ID '{}' not found".format(rid))
-
-    return id_
+from bblfsh.roles import role_id, role_name

bblfsh/node.py

@@ -3,6 +3,8 @@
 from typing import Union, List, cast, Optional, Any
 
 from bblfsh.pyuast import Context, NodeExt, IteratorExt, iterator
+
+from bblfsh.roles import role_id
 from bblfsh.tree_order import TreeOrder
 from bblfsh.type_aliases import ResultMultiType
 
@@ -14,7 +16,7 @@ class NodeTypedGetException(Exception):
 class CompatPosition:
     """
     v1 positions were extracted as node.[start|end]_position.[line|col|offset]. To
-    emulate that, this dictionary will be returned when accesing the old position
+    emulate that, this dictionary will be returned when accessing the old position
     properties and its setters will update the parent Node real position ones.
     """
 
@@ -56,7 +58,7 @@ def __init__(self, parent: "Node") -> None:
         self._par_dict = parent.get_dict()
         self._children = self._sync_children()
 
-    def _sync_children(self) -> None:
+    def _sync_children(self) -> List["Node"]:
         if "_children" not in self._par_dict:
             self._par_dict["_children"] = []
         children = self._par_dict["_children"]
@@ -85,7 +87,7 @@ def __len__(self) -> int:
         return len(self._children)
 
     def __getitem__(self, idx: Union[int, slice]) -> Any:
-        return self._children[idx]
+        return Node(value=self._children[idx])
 
     def __delitem__(self, idx: Union[int, slice]) -> None:
         del self._children[idx]
@@ -214,12 +216,12 @@ def _is_dict_list(self, key: str) -> Optional[List]:
         return val
 
     @property
-    def children(self) -> CompatChildren:
+    def children(self) -> List["Node"]:
         return CompatChildren(self)
 
     @property
     def token(self) -> str:
-        return self.get_dict()["@token"]
+        return self.get_dict().get("@token", "")
 
     @token.setter
     def token(self, t: str) -> None:
@@ -228,35 +230,34 @@ def token(self, t: str) -> None:
 
     @property
     def roles(self) -> List:
-        return self.get_dict().get("@role", [])
+        return [role_id(name) for name in self.get_dict().get("@role", [])]
 
     def _add_position(self) -> None:
         d = self.get_dict()
         if "@pos" not in d:
             d["@pos"] = {
                 "@type": "uast:Positions",
-                "start": {
-                    "@type": "uast:Position",
-                    "offset": -1,
-                    "line": -1,
-                    "col": -1,
-                },
-                "end": {
-                    "@type": "uast:Position",
-                    "offset": -1,
-                    "line": -1,
-                    "col": -1,
-                }
+                "start": Node._get_default_position(),
+                "end": Node._get_default_position()
             }
 
     @property
     def start_position(self) -> CompatPosition:
         self._add_position()
-        start = self.get_dict()["@pos"]["start"]
+        start = self.get_dict()["@pos"].get("start", Node._get_default_position())
         return CompatPosition(start)
 
     @property
     def end_position(self) -> CompatPosition:
         self._add_position()
-        end = self.get_dict()["@pos"]["end"]
+        end = self.get_dict()["@pos"].get("start", Node._get_default_position())
         return CompatPosition(end)
+
+    @staticmethod
+    def _get_default_position():
+        return {
+            "@type": "uast:Position",
+            "offset": 0,
+            "line": 0,
+            "col": 0,
+        }

bblfsh/roles.py

@@ -0,0 +1,23 @@
+from bblfsh.aliases import DESCRIPTOR
+
+
+class RoleSearchException(Exception):
+    pass
+
+
+def role_id(rname: str) -> int:
+    try:
+        name = DESCRIPTOR.enum_types_by_name["Role"].values_by_name[rname.upper()].number
+    except KeyError:
+        raise RoleSearchException("Role with name '{}' not found".format(rname))
+
+    return name
+
+
+def role_name(rid: int) -> str:
+    try:
+        id_ = DESCRIPTOR.enum_types_by_name["Role"].values_by_number[rid].name
+    except KeyError:
+        raise RoleSearchException("Role with ID '{}' not found".format(rid))
+
+    return id_.upper()

bblfsh/test_compat.py

@@ -220,8 +220,8 @@ def testIteratorPositionOrder(self):
         it = iterator(root, TreeOrder.POSITION_ORDER)
         self.assertIsNotNone(it)
         expanded = [node.internal_type for node in it]
-        self.assertListEqual(expanded, ['root', 'son1', 'son2_1', 'son1_1',
-                                        'son1_2', 'son2_2', 'son2'])
+        self.assertListEqual(expanded, ['son1', 'son2_1', 'son1_1',
+                                        'son1_2', 'son2_2', 'son2', 'root'])
 
     def testFilterInsideIter(self):
         root = self._parse_fixture().uast
@@ -288,18 +288,18 @@ def testChildren(self):
         n.internal_type = 'root'
         c1 = {"@type": "child1"}
         n.properties["child1"] = c1
-        self.assertDictEqual(n.children[0], c1)
+        self.assertDictEqual(n.children[0].get_dict(), c1)
 
         c2 = {"@type": "child2"}
         n.children.append(c2)
-        self.assertDictEqual(n.children[1], c2)
+        self.assertDictEqual(n.children[1].get_dict(), c2)
         n.children.append(c2)
-        self.assertDictEqual(n.children[2], c2)
+        self.assertDictEqual(n.children[2].get_dict(), c2)
 
         l = [{"@type": "list_child1"}, {"@type": "list_child2"}]
         n.properties["some_list"] = l
-        self.assertDictEqual(n.children[3], l[0])
-        self.assertDictEqual(n.children[4], l[1])
+        self.assertDictEqual(n.children[3].get_dict(), l[0])
+        self.assertDictEqual(n.children[4].get_dict(), l[1])
 
     def testChildrenFile(self):
         root = self._parse_fixture().uast
@@ -309,8 +309,7 @@ def testChildrenFile(self):
         root.children.append(n)
         self.assertEqual(len(root.children), 11)
         last = root.children[-1]
-        self.assertDictEqual(last, n.internal_node)
-
+        self.assertDictEqual(last.get_dict(), n.internal_node)
 
 
 if __name__ == "__main__":