Merge pull request #20 from divmadan/devel/treelib

Introduce and utilise treelib

Author: diivm

.github/workflows/pytest.yml

@@ -27,8 +27,8 @@ jobs:
       - name: Install pip
         run: python -m pip install --upgrade pip
 
-      - name: Install pytest
-        run: pip install pytest
+      - name: Install packages
+        run: pip install pytest treelib
 
       # Install clang and it's python inteface via apt
       - name: Add llvm keys

clang_bind/clang_utils.py

@@ -118,3 +118,10 @@ def get_properties_dict(self):
             - {property_name, property}
         """
         return self.properties_dict
+
+    def get_all_functions_dict(self):
+        return {
+            **self.check_functions_dict,
+            **self.get_functions_dict,
+            **self.properties_dict,
+        }

clang_bind/parse.py

@@ -1,134 +1,77 @@
 import clang.cindex as clang
+from treelib import Tree
 
-import clang_bind.utils as utils
 from clang_bind.clang_utils import ClangUtils
 
 
+class Node:
+    def __init__(self, cursor, verbose=False):
+        self.cursor = cursor
+        if verbose:
+            # Add additional information about the cursor
+            # Get values from the classes in cindex.py: `is_` methods, `get_` methods, @property values
+            self.cursor_kind = ClangUtils(cursor.kind).get_all_functions_dict()
+            self.cursor = ClangUtils(cursor).get_all_functions_dict()
+            self.type = ClangUtils(cursor.type).get_all_functions_dict()
+
+    def __repr__(self) -> str:
+        return f"{self.cursor.kind.name}:'{self.cursor.spelling}'"
+
+
 class Parse:
     """
-    Class containing functions to generate an AST of a file and parse it to retrieve relevant information.
+    Class to parse a file and generate an AST from it.
     """
 
     def __init__(self, file, compiler_arguments):
         index = clang.Index.create()
-
         """
         - Why parse using the option `PARSE_DETAILED_PROCESSING_RECORD`?
             - Indicates that the parser should construct a detailed preprocessing record, 
             including all macro definitions and instantiations
             - Required to retrieve `CursorKind.INCLUSION_DIRECTIVE`
         """
-
         source_ast = index.parse(
             path=file,
             args=compiler_arguments,
             options=clang.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD,
         )
-
-        self.root_node = {
-            "cursor": source_ast.cursor,
-            "filename": source_ast.spelling,
-            "depth": 0,
-        }
-
-    @staticmethod
-    def _is_valid_child(parent_node, child_node):
-        child = child_node.get("cursor")
-        parent_filename = parent_node.get("filename")
-
-        if child.location.file and child.location.file.name == parent_filename:
-            return True
-        return False
+        self.filename = source_ast.spelling
+        self.tree = Tree()
+        self.root_node = self.tree.create_node(
+            identifier=Node(source_ast.cursor), tag=repr(Node(source_ast.cursor))
+        )
 
     @staticmethod
-    def get_parsed_node(node):
-        cursor = node.get("cursor")
-
-        # Objects to get various kinds of checks available in cindex.py via clang_utils.py
-        cursor_kind_utils = ClangUtils(cursor.kind)
-        cursor_utils = ClangUtils(cursor)
-        cursor_type_utils = ClangUtils(cursor.type)
-
-        parsed_node = {
-            "depth": node.get("depth"),
-            "line": cursor.location.line,
-            "column": cursor.location.column,
-            "tokens": [x.spelling for x in cursor.get_tokens()],
-            "cursor_kind": {
-                **cursor_kind_utils.get_check_functions_dict(),  # Functions that begin with "is_" i.e., checking functions
-                **cursor_kind_utils.get_get_functions_dict(),  # Functions that begin with "get_" i.e., getter functions
-                **cursor_kind_utils.get_properties_dict(),  # Properties
-            },
-            "cursor": {
-                **cursor_utils.get_check_functions_dict(),
-                **cursor_utils.get_get_functions_dict(),
-                **cursor_utils.get_properties_dict(),
-            },
-            "type": {
-                **cursor_type_utils.get_check_functions_dict(),
-                **cursor_type_utils.get_get_functions_dict(),
-                **cursor_type_utils.get_properties_dict(),
-            },
-            "members": [],
-        }
-
-        # HACKY FIXES
-        # get spelling from object
-        parsed_node["cursor"]["result_type"] = parsed_node["cursor"][
-            "result_type"
-        ].spelling
-        # replace `AccessSpecifier.value` with just `value`
-        parsed_node["cursor"]["access_specifier"] = parsed_node["cursor"][
-            "access_specifier"
-        ].name
-        # replace `TypeKind.value` with just `value`
-        parsed_node["type"]["kind"] = parsed_node["type"]["kind"].name
-
-        return parsed_node
-
-    @classmethod
-    def parse_node_recursive(cls, node):
+    def is_node_from_file(node, filename):
         """
-        Generates parsed information by recursively traversing the AST
-
-        Parameters:
-            - node (dict):
-                - The node in the AST
-                - Keys:
-                    - cursor: The cursor pointing to a node
-                    - filename:
-                        - The file's name to check if the node belongs to it
-                        - Needed to ensure that only symbols belonging to the file gets parsed, not the included files' symbols
-                    - depth: The depth of the node (root=0)
-
-        Returns:
-            - parsed_info (dict):
-                - Contains key-value pairs of various traits of a node
-                - The key 'members' contains the node's children's `parsed_info`
+        Check if the node belongs in the file.
         """
+        return node.location.file and node.location.file.name == filename
 
-        cursor = node.get("cursor")
-        filename = node.get("filename")
-        depth = node.get("depth")
-
-        parsed_info = cls.get_parsed_node(node)
-
-        # Get cursor's children and recursively add their info to a dictionary, as members of the parent
-        for child in cursor.get_children():
-            child_node = {"cursor": child, "filename": filename, "depth": depth + 1}
-            if cls._is_valid_child(node, child_node):
-                child_parsed_info = cls.parse_node_recursive(child_node)
-                parsed_info["members"].append(child_parsed_info)
-
-        return parsed_info
-
-    def get_parsed_info(self):
+    def _is_valid_child(self, child_cursor):
+        """
+        Check if the child is valid (child should be in the same file as the parent).
         """
-        Returns the parsed information for a file by recursively traversing the AST
+        return self.is_node_from_file(child_cursor, self.filename)
 
-        Returns:
-            - parsed_info (dict):
-                - Contains key-value pairs of various traits of a node
-                - The key 'members' contains the node's children's `parsed_info`
+    def _construct_tree(self, node):
+        """
+        Recursively generates tree by traversing the AST of the node.
+        """
+        cursor = node.identifier.cursor
+        for child_cursor in cursor.get_children():
+            if self._is_valid_child(child_cursor):
+                child_node = self.tree.create_node(
+                    identifier=Node(child_cursor),
+                    parent=node,
+                    tag=repr(Node(child_cursor)),
+                )
+                self._construct_tree(child_node)
+
+    def get_tree(self):
+        """
+        Returns the constructed tree.
         """
-        return self.parse_node_recursive(self.root_node)
+        self._construct_tree(self.root_node)
+        return self.tree

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+
+testpaths = tests/test_parse.py