Merge pull request #10 from gouthamgandhi/fix/c-codebase-leaf-node-detection

Fix: C codebase documentation generation finding 0 leaf nodes

Author: brianminhle

codewiki/src/be/dependency_analyzer/analyzers/c.py

@@ -64,7 +64,7 @@ def _analyze(self):
 		self._extract_relationships(root, top_level_nodes)
 
 	def _extract_nodes(self, node, top_level_nodes, lines):
-		"""Recursively extract top-level nodes (functions and global variables)."""
+		"""Recursively extract top-level nodes (functions, structs, and global variables)."""
 		node_type = None
 		node_name = None
 
@@ -76,6 +76,24 @@ def _extract_nodes(self, node, top_level_nodes, lines):
 				identifier = next((c for c in declarator.children if c.type == "identifier"), None)
 				if identifier:
 					node_name = identifier.text.decode()
+		elif node.type == "struct_specifier":
+			# Extract struct definitions: struct Name { ... }
+			node_type = "struct"
+			# Find type_identifier that represents the struct name
+			for child in node.children:
+				if child.type == "type_identifier":
+					node_name = child.text.decode()
+					break
+		elif node.type == "type_definition":
+			# Handle typedef struct definitions: typedef struct { ... } Name;
+			# Check if this typedef contains a struct
+			struct_spec = next((c for c in node.children if c.type == "struct_specifier"), None)
+			if struct_spec:
+				node_type = "struct"
+				# The typedef name is the type_identifier at the end
+				type_declarator = next((c for c in node.children if c.type == "type_identifier"), None)
+				if type_declarator:
+					node_name = type_declarator.text.decode()
 		elif node.type == "declaration":
 			if self._is_global_variable(node):
 				node_type = "variable"
@@ -117,7 +135,7 @@ def _extract_nodes(self, node, top_level_nodes, lines):
 				component_id=component_id
 			)
 
-			if node_type == "function":
+			if node_type in ["function", "struct"]:
 				self.nodes.append(node_obj)
 			top_level_nodes[node_name] = node_obj
 

codewiki/src/be/dependency_analyzer/analyzers/python.py

@@ -1,5 +1,6 @@
 import ast
 import logging
+import warnings
 from typing import List, Tuple, Optional
 from pathlib import Path
 import sys
@@ -227,7 +228,11 @@ def analyze(self):
         """Analyze the Python file and extract functions and relationships."""
 
         try:
-            tree = ast.parse(self.content)
+            # Suppress SyntaxWarnings about invalid escape sequences in source code
+            # These warnings come from regex patterns like '\(' or '\.' in the analyzed files
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=SyntaxWarning)
+                tree = ast.parse(self.content)
             self.visit(tree)
 
             logger.debug(

codewiki/src/be/dependency_analyzer/dependency_graphs_builder.py

@@ -61,7 +61,20 @@ def build_dependency_graph(self) -> tuple[Dict[str, Any], List[str]]:
         # Get leaf nodes
         leaf_nodes = get_leaf_nodes(graph, components)
 
-        # check if leaf_nodes are in components, only keep the ones that are in components and type is one of the following: class, interface, struct
+        # check if leaf_nodes are in components, only keep the ones that are in components
+        # and type is one of the following: class, interface, struct (or function for C-based projects)
+        
+        # Determine if we should include functions based on available component types
+        available_types = set()
+        for comp in components.values():
+            available_types.add(comp.component_type)
+        
+        # Valid types for leaf nodes - include functions for C-based codebases
+        valid_types = {"class", "interface", "struct"}
+        # If no classes/interfaces/structs are found, include functions
+        if not available_types.intersection(valid_types):
+            valid_types.add("function")
+        
         keep_leaf_nodes = []
         for leaf_node in leaf_nodes:
             # Skip any leaf nodes that are clearly error strings or invalid identifiers
@@ -70,7 +83,7 @@ def build_dependency_graph(self) -> tuple[Dict[str, Any], List[str]]:
                 continue
 
             if leaf_node in components:
-                if components[leaf_node].component_type in ["class", "interface", "struct"]:
+                if components[leaf_node].component_type in valid_types:
                     keep_leaf_nodes.append(leaf_node)
                 else:
                     # logger.debug(f"Leaf node {leaf_node} is a {components[leaf_node].component_type}, removing it")

codewiki/src/be/dependency_analyzer/topo_sort.py

@@ -302,6 +302,18 @@ def concise_node(leaf_nodes: Set[str]) -> Set[str]:
                 concise_leaf_nodes.add(node)
 
         keep_leaf_nodes = []
+        
+        # Determine if we should include functions based on available component types
+        # For C-based projects, we need to include functions since they don't have classes
+        available_types = set()
+        for comp in components.values():
+            available_types.add(comp.component_type)
+        
+        # Valid types for leaf nodes - include functions for C-based codebases
+        valid_types = {"class", "interface", "struct"}
+        # If no classes/interfaces/structs are found, include functions
+        if not available_types.intersection(valid_types):
+            valid_types.add("function")
 
         for leaf_node in leaf_nodes:
             # Skip any leaf nodes that are clearly error strings or invalid identifiers
@@ -310,7 +322,7 @@ def concise_node(leaf_nodes: Set[str]) -> Set[str]:
                 continue
 
             if leaf_node in components:
-                if components[leaf_node].component_type in ["class", "interface", "struct"]:
+                if components[leaf_node].component_type in valid_types:
                     keep_leaf_nodes.append(leaf_node)
                 else:
                     # logger.debug(f"Leaf node {leaf_node} is a {components[leaf_node].component_type}, removing it")