debug code for not detecting component

Author: Jason2866

builder/frameworks/component_manager.py

@@ -120,34 +120,54 @@ def _analyze_project_dependencies(self) -> Set[str]:
         """Analyze project files to detect actually used components/libraries."""
         used_components = set()
 
+        print(f"DEBUG: Starting project analysis")
+        
         try:
-            # Analyze project source files
             src_dir = self.env.subst("$PROJECT_SRC_DIR")
+            print(f"DEBUG: Scanning source directory: {src_dir}")
+            
             if os.path.exists(src_dir):
+                file_count = 0
                 for root, dirs, files in os.walk(src_dir):
                     for file in files:
                         if file.endswith(('.cpp', '.c', '.h', '.hpp', '.ino')):
+                            file_count += 1
                             file_path = os.path.join(root, file)
-                            used_components.update(self._extract_components_from_file(file_path))
+                            file_components = self._extract_components_from_file(file_path)
+                            if file_components:
+                                print(f"DEBUG: File {file} detected components: {file_components}")
+                            used_components.update(file_components)
+                
+                print(f"DEBUG: Scanned {file_count} source files")
 
-            # Analyze lib_deps for explicit dependencies (if available)
+            # Check lib_deps
             lib_deps = self.env.GetProjectOption("lib_deps", [])
-            if isinstance(lib_deps, str):
-                lib_deps = [lib_deps]
-            
-            for dep in lib_deps:
-                used_components.update(self._extract_components_from_lib_dep(str(dep)))
+            if lib_deps:
+                print(f"DEBUG: Found lib_deps: {lib_deps}")
+                if isinstance(lib_deps, str):
+                    lib_deps = [lib_deps]
 
-        except Exception:
-            pass
+                for dep in lib_deps:
+                    dep_components = self._extract_components_from_lib_dep(str(dep))
+                    if dep_components:
+                        print(f"DEBUG: lib_dep '{dep}' mapped to components: {dep_components}")
+                    used_components.update(dep_components)
+            else:
+                print(f"DEBUG: No lib_deps found")
+                
+        except Exception as e:
+            print(f"DEBUG: Exception in project analysis: {e}")
+            import traceback
+            traceback.print_exc()
 
+        print(f"DEBUG: Final detected components: {used_components}")
         return used_components
 
     def _extract_components_from_file(self, file_path: str) -> Set[str]:
         """Extract component usage from a single file by analyzing includes and function calls."""
         components = set()
 
-        # Component detection patterns - maps component names to search patterns
+        # Component detection patterns - maps component names to code patterns
         component_patterns = {
             'bt': ['bluetooth', 'ble', 'nimble', 'bt_', 'esp_bt', 'esp_ble'],
             'esp_wifi': ['wifi', 'esp_wifi', 'tcpip_adapter'],
@@ -163,14 +183,18 @@ def _extract_components_from_file(self, file_path: str) -> Set[str]:
             'driver': ['gpio_', 'uart_', 'spi_', 'i2c_', 'adc_', 'dac_'],
             'esp_camera': ['esp_camera', 'camera.h'],
             'esp_now': ['esp_now', 'espnow'],
-            'esp_smartconfig': ['smartconfig', 'esp_smartconfig']
+            'esp_smartconfig': ['smartconfig', 'esp_smartconfig'],
+            'esp_eth': ['esp_eth', 'ethernet'],
+            'esp_websocket_client': ['websocket', 'esp_websocket'],
+            'cjson': ['cjson', 'json'],
+            'mbedtls': ['mbedtls', 'ssl'],
+            'openssl': ['openssl']
         }
 
         try:
             with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                 content = f.read().lower()
 
-                # Check each component pattern against file content
                 for component, patterns in component_patterns.items():
                     if any(pattern in content for pattern in patterns):
                         components.add(component)
@@ -181,7 +205,7 @@ def _extract_components_from_file(self, file_path: str) -> Set[str]:
         return components
 
     def _extract_components_from_lib_dep(self, lib_dep: str) -> Set[str]:
-        """Extract components from lib_deps entry by mapping library names to components."""
+        """Extract components from lib_deps entry by mapping library names to ESP-IDF components."""
         components = set()
         lib_dep_upper = lib_dep.upper()
 
@@ -192,7 +216,10 @@ def _extract_components_from_lib_dep(self, lib_dep: str) -> Set[str]:
             'esp_dsp': ['DSP', 'FFT', 'JPEG'],
             'esp_http_client': ['HTTP', 'HTTPCLIENT'],
             'mqtt': ['MQTT', 'PUBSUB'],
-            'esp_camera': ['CAMERA', 'ESP32CAM']
+            'esp_camera': ['CAMERA', 'ESP32CAM'],
+            'esp_now': ['ESPNOW', 'ESP_NOW'],
+            'mdns': ['MDNS'],
+            'esp_eth': ['ETHERNET']
         }
 
         for component, keywords in lib_dep_mapping.items():
@@ -203,7 +230,7 @@ def _extract_components_from_lib_dep(self, lib_dep: str) -> Set[str]:
 
     def _is_component_used_in_project(self, lib_name: str) -> bool:
         """Check if a component/library is actually used in the project."""
-        # Cache project analysis results for performance
+        # Cache project analysis for performance
         if not hasattr(self, '_project_components_cache'):
             self._project_components_cache = self._analyze_project_dependencies()
 
@@ -406,23 +433,36 @@ def _remove_ignored_lib_includes(self) -> None:
         build_py_path = join(self.arduino_libs_mcu, "pioarduino-build.py")
 
         if not os.path.exists(build_py_path):
+            print(f"DEBUG: Build file not found: {build_py_path}")
             return
 
+        print(f"DEBUG: Starting lib_ignore processing")
+        print(f"DEBUG: ignored_libs = {list(self.ignored_libs)}")
+        
+        # Force project analysis and show results
+        self._project_components_cache = self._analyze_project_dependencies()
+        print(f"DEBUG: Detected project components: {list(self._project_components_cache)}")
+        
         try:
             with open(build_py_path, 'r') as f:
                 content = f.read()
 
             original_content = content
             total_removed = 0
 
-            # Remove CPPPATH entries for each ignored library
+            # Check each library individually
             for lib_name in self.ignored_libs:
-                # Universal protection: Skip if component is actually used in project
-                if self._is_component_used_in_project(lib_name):
-                    print(f"Skipping removal of library '{lib_name}' - detected as used in project")
+                print(f"DEBUG: Processing lib_name = '{lib_name}'")
+                
+                # Check if component is used
+                is_used = self._is_component_used_in_project(lib_name)
+                print(f"DEBUG: Is '{lib_name}' used in project? {is_used}")
+                
+                if is_used:
+                    print(f"DEBUG: SKIPPING '{lib_name}' - detected as used")
                     continue
-                    
-                # Multiple patterns to catch different include formats
+                
+                # Check what would be removed
                 patterns = [
                     rf'.*join\([^,]*,\s*"include",\s*"{re.escape(lib_name)}"[^)]*\),?\n',
                     rf'.*"include/{re.escape(lib_name)}"[^,\n]*,?\n',
@@ -434,23 +474,41 @@ def _remove_ignored_lib_includes(self) -> None:
                     rf'\s*"[^"]*/{re.escape(lib_name)}/[^"]*",?\n'
                 ]
 
+                matches_found = []
                 for pattern in patterns:
                     matches = re.findall(pattern, content)
                     if matches:
+                        matches_found.extend(matches)
+                
+                if matches_found:
+                    print(f"DEBUG: REMOVING '{lib_name}' - found {len(matches_found)} matches:")
+                    for match in matches_found:
+                        print(f"DEBUG:   - {match.strip()}")
+                    
+                    for pattern in patterns:
                         content = re.sub(pattern, '', content)
-                        total_removed += len(matches)
+                        total_removed += len(re.findall(pattern, original_content))
+                else:
+                    print(f"DEBUG: No matches found for '{lib_name}'")
+            
+            print(f"DEBUG: Total lines removed: {total_removed}")
 
             # Clean up empty lines and trailing commas
             content = re.sub(r'\n\s*\n', '\n', content)
             content = re.sub(r',\s*\n\s*\]', '\n]', content)
 
             # Validate and write changes
             if self._validate_changes(original_content, content) and content != original_content:
+                print(f"DEBUG: Content changed, writing new file")
                 with open(build_py_path, 'w') as f:
                     f.write(content)
+            else:
+                print(f"DEBUG: No changes made to build file")
 
-        except Exception:
-            pass
+        except Exception as e:
+            print(f"DEBUG: Exception occurred: {e}")
+            import traceback
+            traceback.print_exc()
 
     def _validate_changes(self, original_content: str, new_content: str) -> bool:
         """Validate that the changes are reasonable."""