Merge pull request #27 from divmadan/fix/parsed_tree

Changes in parse.py

Author: diivm

clang_bind/parse.py

@@ -4,7 +4,15 @@
 from clang_bind.clang_utils import ClangUtils
 
 
-class Node:
+class ParsedInfo:
+    """This is a data holder class containing parsed info, to be used while constructing the tree.
+
+    :param cursor: An object of :class:`clang.cindex.Cursor`
+    :type cursor: class:`clang.cindex.Cursor`
+    :param verbose: Add additional information about the cursor, defaults to False
+    :type verbose: bool, optional
+    """
+
     def __init__(self, cursor, verbose=False):
         self.cursor = cursor
         if verbose:
@@ -19,11 +27,16 @@ def __repr__(self) -> str:
 
 
 class Parse:
-    """
-    Class to parse a file and generate an AST from it.
+    """This is a class which parses a file and generate an abstract syntax tree from it.
+
+    :param file: File to parse
+    :type file: str
+    :param compiler_arguments: Compiler arguments to use while parsing
+    :type compiler_arguments: list, optional
     """
 
-    def __init__(self, file, compiler_arguments):
+    def __init__(self, file, compiler_arguments=[]):
+        self._parsed_info_map = {}
         index = clang.Index.create()
         """
         - Why parse using the option `PARSE_DETAILED_PROCESSING_RECORD`?
@@ -38,40 +51,124 @@ def __init__(self, file, compiler_arguments):
         )
         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))
-        )
+        parsed_info = ParsedInfo(source_ast.cursor)
+        self.root_node = self.tree.create_node(tag=repr(parsed_info))
+        self._parsed_info_map[self.root_node.identifier] = parsed_info
+        self._construct_tree(self.root_node)
 
     @staticmethod
-    def is_node_from_file(node, filename):
-        """
-        Check if the node belongs in the file.
+    def is_cursor_in_file(cursor, filename):
+        """Checks if the cursor belongs in the file.
+
+        :param cursor: An object of :class:`clang.cindex.Cursor`
+        :type cursor: class:`clang.cindex.Cursor`
+        :param filename: Filename to search the cursor
+        :type filename: str
+        :return: `True` if cursor in file, else `False`
+        :rtype: bool
         """
-        return node.location.file and node.location.file.name == filename
+        return cursor.location.file and cursor.location.file.name == filename
 
     def _is_valid_child(self, child_cursor):
+        """Checks if the child is valid (child should be in the same file as the parent).
+
+        :param child_cursor: The child cursor to check, an object of :class:`clang.cindex.Cursor`
+        :type child_cursor: class:`clang.cindex.Cursor`
+        :return: `True` if child cursor in file, else `False`
+        :rtype: bool
         """
-        Check if the child is valid (child should be in the same file as the parent).
-        """
-        return self.is_node_from_file(child_cursor, self.filename)
+        return self.is_cursor_in_file(child_cursor, self.filename)
 
     def _construct_tree(self, node):
+        """Recursively generates tree by traversing the AST of the node.
+
+        :param node: An object of :class:`treelib.Node`
+        :type node: class:`treelib.Node`
         """
-        Recursively generates tree by traversing the AST of the node.
-        """
-        cursor = node.identifier.cursor
+        cursor = self.get_parsed_info_from_node_id(node.identifier).cursor
         for child_cursor in cursor.get_children():
             if self._is_valid_child(child_cursor):
+                parsed_info = ParsedInfo(child_cursor)
                 child_node = self.tree.create_node(
-                    identifier=Node(child_cursor),
                     parent=node,
-                    tag=repr(Node(child_cursor)),
+                    tag=repr(parsed_info),
                 )
+                self._parsed_info_map[child_node.identifier] = parsed_info
                 self._construct_tree(child_node)
 
     def get_tree(self):
+        """Returns the constructed AST.
+
+        :return: Constructed AST
+        :rtype: class:`treelib.Tree`
         """
-        Returns the constructed tree.
-        """
-        self._construct_tree(self.root_node)
         return self.tree
+
+    def get_node_id_from_parsed_info(self, parsed_info):
+        """Returns node identifier by performing a value based search of `_parsed_info_map`.
+
+        :param parsed_info: An object of :class:`clang_bind.parse.ParsedInfo`
+        , the value to get the corresponding key from `_parsed_info_map`
+        :type parsed_info`: class:`clang_bind.parse.ParsedInfo`
+        :return node_id: Node identifier corresponding to `parsed_info`
+        :rtype: `treelib.Tree.identifier`
+        """
+        for node_id, parsed_info_ in self._parsed_info_map.items():
+            if parsed_info_ == parsed_info:
+                return node_id
+
+    def get_children_nodes_from_parent_parsed_info(self, parent_parsed_info):
+        """Returns a list of children nodes from parent parsed infos.
+
+        :param parent_parsed_info: The parent object of :class:`clang_bind.parse.ParsedInfo`
+        :type parent_parsed_info: class:`clang_bind.parse.ParsedInfo`
+        :return: Children nodes of :class:`treelib.Node`
+        :rtype: list
+        """
+        return self.tree.children(self.get_node_id_from_parsed_info(parent_parsed_info))
+
+    def get_parsed_infos_from_node_ids(self, node_ids):
+        """Returns a list of parsed infos from a list of node identifiers
+        , by getting the values from `_parsed_info_map`
+
+        :param node_ids: Node identifiers of :class:`treelib.Node`
+        :type node_ids: list
+        :return: Parsed infos of :class:`clang_bind.parse.ParsedInfo`
+        :rtype: list
+        """
+        return list(map(lambda node_id: self._parsed_info_map.get(node_id), node_ids))
+
+    def get_parsed_info_from_node_id(self, node_id):
+        """Returns parsed info from node identifier, by getting the value from `_parsed_info_map`
+
+        :param node_id: Node identifier
+        :type node_id: class:`treelib.Node`
+        :return: Parsed info corresponding to `node_id`
+        :rtype: class:`clang_bind.parse.ParsedInfo`
+        """
+        return self.get_parsed_infos_from_node_ids([node_id])[0]
+
+    @staticmethod
+    def get_node_ids_from_nodes(nodes):
+        """Returns a list of node identifiers from a list of nodes.
+
+        :param nodes: A list of objects of :class:`treelib.Node`
+        :type nodes: class:`treelib.Node`
+        :return: A list of node identifiers of `treelib.Tree.identifier`
+        :rtype: list
+        """
+        return list(map(lambda node: node.identifier, nodes))
+
+    def get_children_parsed_infos_from_parent_parsed_info(self, parent_parsed_info):
+        """Returns children parsed infos from parent parsed infos.
+
+        :param parent_parsed_info: The parent object of :class:`clang_bind.parse.ParsedInfo`
+        :type parent_parsed_info: class:`clang_bind.parse.ParsedInfo`
+        :return: Children parsed infos of :class:`clang_bind.parse.ParsedInfo`
+        :rtype: list
+        """
+        return self.get_parsed_infos_from_node_ids(
+            self.get_node_ids_from_nodes(
+                self.get_children_nodes_from_parent_parsed_info(parent_parsed_info)
+            )
+        )