tree-sitter-analyzer 1.8.4__py3-none-any.whl → 1.9.0__py3-none-any.whl

tree_sitter_analyzer/languages/html_plugin.py

@@ -8,7 +8,7 @@ attribute parsing, and document structure analysis.
 """
 
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from ..models import AnalysisResult, MarkupElement
 from ..plugins.base import ElementExtractor, LanguagePlugin
@@ -28,14 +28,80 @@ class HtmlElementExtractor(ElementExtractor):
     def __init__(self):
         self.element_categories = {
             # HTML要素の分類システム
-            "structure": ["html", "body", "div", "span", "section", "article", "aside", "nav", "main", "header", "footer"],
+            "structure": [
+                "html",
+                "body",
+                "div",
+                "span",
+                "section",
+                "article",
+                "aside",
+                "nav",
+                "main",
+                "header",
+                "footer",
+            ],
             "heading": ["h1", "h2", "h3", "h4", "h5", "h6"],
-            "text": ["p", "a", "strong", "em", "b", "i", "u", "small", "mark", "del", "ins", "sub", "sup"],
+            "text": [
+                "p",
+                "a",
+                "strong",
+                "em",
+                "b",
+                "i",
+                "u",
+                "small",
+                "mark",
+                "del",
+                "ins",
+                "sub",
+                "sup",
+            ],
             "list": ["ul", "ol", "li", "dl", "dt", "dd"],
-            "media": ["img", "video", "audio", "source", "track", "canvas", "svg", "picture"],
-            "form": ["form", "input", "textarea", "button", "select", "option", "optgroup", "label", "fieldset", "legend"],
-            "table": ["table", "thead", "tbody", "tfoot", "tr", "td", "th", "caption", "colgroup", "col"],
-            "metadata": ["head", "title", "meta", "link", "style", "script", "noscript", "base"]
+            "media": [
+                "img",
+                "video",
+                "audio",
+                "source",
+                "track",
+                "canvas",
+                "svg",
+                "picture",
+            ],
+            "form": [
+                "form",
+                "input",
+                "textarea",
+                "button",
+                "select",
+                "option",
+                "optgroup",
+                "label",
+                "fieldset",
+                "legend",
+            ],
+            "table": [
+                "table",
+                "thead",
+                "tbody",
+                "tfoot",
+                "tr",
+                "td",
+                "th",
+                "caption",
+                "colgroup",
+                "col",
+            ],
+            "metadata": [
+                "head",
+                "title",
+                "meta",
+                "link",
+                "style",
+                "script",
+                "noscript",
+                "base",
+            ],
         }
 
     def extract_functions(self, tree: "tree_sitter.Tree", source_code: str) -> list:
@@ -54,13 +120,17 @@ class HtmlElementExtractor(ElementExtractor):
         """HTML doesn't have imports, return empty list"""
         return []
 
-    def extract_html_elements(self, tree: "tree_sitter.Tree", source_code: str) -> list[MarkupElement]:
+    def extract_html_elements(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> list[MarkupElement]:
         """Extract HTML elements using tree-sitter-html parser"""
         elements = []
-        
+
         try:
             if hasattr(tree, "root_node"):
-                self._traverse_for_html_elements(tree.root_node, elements, source_code, None)
+                self._traverse_for_html_elements(
+                    tree.root_node, elements, source_code, None
+                )
         except Exception as e:
             log_error(f"Error in HTML element extraction: {e}")
 
@@ -71,7 +141,7 @@ class HtmlElementExtractor(ElementExtractor):
         node: "tree_sitter.Node",
         elements: list[MarkupElement],
         source_code: str,
-        parent: MarkupElement | None
+        parent: MarkupElement | None,
     ) -> None:
         """Traverse tree to find HTML elements using tree-sitter-html grammar"""
         if hasattr(node, "type") and self._is_html_element_node(node.type):
@@ -79,11 +149,13 @@ class HtmlElementExtractor(ElementExtractor):
                 element = self._create_markup_element(node, source_code, parent)
                 if element:
                     elements.append(element)
-                    
+
                     # Process children with this element as parent
                     if hasattr(node, "children"):
                         for child in node.children:
-                            self._traverse_for_html_elements(child, elements, source_code, element)
+                            self._traverse_for_html_elements(
+                                child, elements, source_code, element
+                            )
                     return
             except Exception as e:
                 log_debug(f"Failed to extract HTML element: {e}")
@@ -101,15 +173,12 @@ class HtmlElementExtractor(ElementExtractor):
             "self_closing_tag",
             "script_element",
             "style_element",
-            "void_element"
+            "void_element",
         ]
         return node_type in html_element_types
 
     def _create_markup_element(
-        self, 
-        node: "tree_sitter.Node", 
-        source_code: str, 
-        parent: MarkupElement | None
+        self, node: "tree_sitter.Node", source_code: str, parent: MarkupElement | None
     ) -> MarkupElement | None:
         """Create MarkupElement from tree-sitter node using tree-sitter-html grammar"""
         try:
@@ -130,7 +199,9 @@ class HtmlElementExtractor(ElementExtractor):
             # Create MarkupElement
             element = MarkupElement(
                 name=tag_name,
-                start_line=node.start_point[0] + 1 if hasattr(node, "start_point") else 0,
+                start_line=node.start_point[0] + 1
+                if hasattr(node, "start_point")
+                else 0,
                 end_line=node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
                 raw_text=raw_text,
                 language="html",
@@ -138,7 +209,7 @@ class HtmlElementExtractor(ElementExtractor):
                 attributes=attributes,
                 parent=parent,
                 children=[],
-                element_class=element_class
+                element_class=element_class,
             )
 
             # Add to parent's children if parent exists
@@ -164,38 +235,52 @@ class HtmlElementExtractor(ElementExtractor):
                         elif child.type in ["start_tag", "self_closing_tag"]:
                             # Look for tag_name within start_tag or self_closing_tag
                             for grandchild in child.children:
-                                if hasattr(grandchild, "type") and grandchild.type == "tag_name":
-                                    return self._extract_node_text(grandchild, source_code).strip()
-            
+                                if (
+                                    hasattr(grandchild, "type")
+                                    and grandchild.type == "tag_name"
+                                ):
+                                    return self._extract_node_text(
+                                        grandchild, source_code
+                                    ).strip()
+
             # Fallback: try to extract from node text
             node_text = self._extract_node_text(node, source_code)
             if node_text.startswith("<"):
                 # Extract tag name from <tagname ...> pattern
                 tag_part = node_text.split(">")[0].split()[0]
                 return tag_part.lstrip("<").rstrip(">")
-            
+
             return "unknown"
         except Exception:
             return "unknown"
 
-    def _extract_attributes(self, node: "tree_sitter.Node", source_code: str) -> dict[str, str]:
+    def _extract_attributes(
+        self, node: "tree_sitter.Node", source_code: str
+    ) -> dict[str, str]:
         """Extract attributes from HTML element node using tree-sitter-html grammar"""
         attributes = {}
-        
+
         try:
             if hasattr(node, "children"):
                 for child in node.children:
                     if hasattr(child, "type"):
                         # Handle attribute nodes in tree-sitter-html
                         if child.type == "attribute":
-                            attr_name, attr_value = self._parse_attribute(child, source_code)
+                            attr_name, attr_value = self._parse_attribute(
+                                child, source_code
+                            )
                             if attr_name:
                                 attributes[attr_name] = attr_value
                         elif child.type in ["start_tag", "self_closing_tag"]:
                             # Look for attributes within start_tag or self_closing_tag
                             for grandchild in child.children:
-                                if hasattr(grandchild, "type") and grandchild.type == "attribute":
-                                    attr_name, attr_value = self._parse_attribute(grandchild, source_code)
+                                if (
+                                    hasattr(grandchild, "type")
+                                    and grandchild.type == "attribute"
+                                ):
+                                    attr_name, attr_value = self._parse_attribute(
+                                        grandchild, source_code
+                                    )
                                     if attr_name:
                                         attributes[attr_name] = attr_value
         except Exception as e:
@@ -203,23 +288,34 @@ class HtmlElementExtractor(ElementExtractor):
 
         return attributes
 
-    def _parse_attribute(self, attr_node: "tree_sitter.Node", source_code: str) -> tuple[str, str]:
+    def _parse_attribute(
+        self, attr_node: "tree_sitter.Node", source_code: str
+    ) -> tuple[str, str]:
         """Parse individual attribute node using tree-sitter-html grammar"""
         try:
             # In tree-sitter-html, attributes have specific structure
             attr_name = ""
             attr_value = ""
-            
+
             if hasattr(attr_node, "children"):
                 for child in attr_node.children:
                     if hasattr(child, "type"):
                         if child.type == "attribute_name":
-                            attr_name = self._extract_node_text(child, source_code).strip()
+                            attr_name = self._extract_node_text(
+                                child, source_code
+                            ).strip()
                         elif child.type == "quoted_attribute_value":
-                            attr_value = self._extract_node_text(child, source_code).strip().strip('"').strip("'")
+                            attr_value = (
+                                self._extract_node_text(child, source_code)
+                                .strip()
+                                .strip('"')
+                                .strip("'")
+                            )
                         elif child.type == "attribute_value":
-                            attr_value = self._extract_node_text(child, source_code).strip()
-            
+                            attr_value = self._extract_node_text(
+                                child, source_code
+                            ).strip()
+
             # Fallback to simple parsing
             if not attr_name:
                 attr_text = self._extract_node_text(attr_node, source_code)
@@ -231,7 +327,7 @@ class HtmlElementExtractor(ElementExtractor):
                     # Boolean attribute
                     attr_name = attr_text.strip()
                     attr_value = ""
-            
+
             return attr_name, attr_value
         except Exception:
             return "", ""
@@ -239,11 +335,11 @@ class HtmlElementExtractor(ElementExtractor):
     def _classify_element(self, tag_name: str) -> str:
         """Classify HTML element based on tag name"""
         tag_name_lower = tag_name.lower()
-        
+
         for category, tags in self.element_categories.items():
             if tag_name_lower in tags:
                 return category
-        
+
         return "unknown"
 
     def _extract_node_text(self, node: "tree_sitter.Node", source_code: str) -> str:
@@ -277,13 +373,16 @@ class HtmlPlugin(LanguagePlugin):
     def get_queries(self) -> dict[str, str]:
         """Return HTML-specific tree-sitter queries"""
         from ..queries.html import HTML_QUERIES
+
         return HTML_QUERIES
 
-    def execute_query_strategy(self, query_key: str | None, language: str) -> str | None:
+    def execute_query_strategy(
+        self, query_key: str | None, language: str
+    ) -> str | None:
         """Execute query strategy for HTML"""
         if language != "html":
             return None
-        
+
         queries = self.get_queries()
         return queries.get(query_key) if query_key else None
 
@@ -297,44 +396,40 @@ class HtmlPlugin(LanguagePlugin):
             "media": ["element"],
             "form": ["element"],
             "table": ["element"],
-            "metadata": ["element"]
+            "metadata": ["element"],
         }
 
     async def analyze_file(
         self, file_path: str, request: "AnalysisRequest"
     ) -> "AnalysisResult":
         """Analyze HTML file using tree-sitter-html parser"""
-        from ..core.analysis_engine import UnifiedAnalysisEngine
         from ..encoding_utils import read_file_safe
 
         try:
             # Read file content
             content, encoding = read_file_safe(file_path)
-            
-            # Create analysis engine
-            engine = UnifiedAnalysisEngine()
-            
+
             # Use tree-sitter-html for parsing
             try:
-                import tree_sitter_html as ts_html
                 import tree_sitter
-                
+                import tree_sitter_html as ts_html
+
                 # Get HTML language
                 HTML_LANGUAGE = tree_sitter.Language(ts_html.language())
-                
+
                 # Create parser
                 parser = tree_sitter.Parser()
                 parser.language = HTML_LANGUAGE
-                
+
                 # Parse the HTML content
-                tree = parser.parse(content.encode('utf-8'))
-                
+                tree = parser.parse(content.encode("utf-8"))
+
                 # Extract elements using the extractor
                 extractor = self.create_extractor()
                 elements = extractor.extract_html_elements(tree, content)
-                
+
                 log_info(f"Extracted {len(elements)} HTML elements from {file_path}")
-                
+
                 return AnalysisResult(
                     file_path=file_path,
                     language="html",
@@ -344,15 +439,17 @@ class HtmlPlugin(LanguagePlugin):
                     query_results={},
                     source_code=content,
                     success=True,
-                    error_message=None
+                    error_message=None,
                 )
-                
+
             except ImportError:
-                log_error("tree-sitter-html not available, falling back to basic parsing")
+                log_error(
+                    "tree-sitter-html not available, falling back to basic parsing"
+                )
                 # Fallback to basic parsing
                 lines = content.splitlines()
                 line_count = len(lines)
-                
+
                 # Create basic MarkupElement for the HTML document
                 html_element = MarkupElement(
                     name="html",
@@ -364,7 +461,7 @@ class HtmlPlugin(LanguagePlugin):
                     attributes={},
                     parent=None,
                     children=[],
-                    element_class="structure"
+                    element_class="structure",
                 )
                 elements = [html_element]
 
@@ -377,7 +474,7 @@ class HtmlPlugin(LanguagePlugin):
                     query_results={},
                     source_code=content,
                     success=True,
-                    error_message=None
+                    error_message=None,
                 )
 
         except Exception as e:
@@ -391,5 +488,5 @@ class HtmlPlugin(LanguagePlugin):
                 query_results={},
                 source_code="",
                 success=False,
-                error_message=str(e)
-            )
+                error_message=str(e),
+            )

tree_sitter_analyzer/languages/java_plugin.py

@@ -201,7 +201,7 @@ class JavaElementExtractor(ElementExtractor):
                         import_name = static_match.group(1)
                         if import_content.endswith(".*"):
                             import_name = import_name.replace(".*", "")
-                        
+
                         # For static imports, extract the class name (remove method/field name)
                         parts = import_name.split(".")
                         if len(parts) > 1:
@@ -261,7 +261,7 @@ class JavaElementExtractor(ElementExtractor):
         if tree is None or tree.root_node is None:
             log_debug("Tree or root_node is None, returning empty packages list")
             return packages
-            
+
         for child in tree.root_node.children:
             if child.type == "package_declaration":
                 package_info = self._extract_package_element(child)
@@ -1061,7 +1061,7 @@ class JavaElementExtractor(ElementExtractor):
                     # Handle wildcard case
                     if import_content.endswith(".*"):
                         import_name = import_name.replace(".*", "")
-                    
+
                     # For static imports, extract the class name (remove method/field name)
                     parts = import_name.split(".")
                     if len(parts) > 1:
@@ -1111,7 +1111,7 @@ class JavaElementExtractor(ElementExtractor):
     def extract_elements(self, tree: "tree_sitter.Tree", source_code: str) -> list:
         """Extract elements from source code using tree-sitter AST"""
         elements = []
-        
+
         try:
             elements.extend(self.extract_functions(tree, source_code))
             elements.extend(self.extract_classes(tree, source_code))
@@ -1119,7 +1119,7 @@ class JavaElementExtractor(ElementExtractor):
             elements.extend(self.extract_imports(tree, source_code))
         except Exception as e:
             log_error(f"Failed to extract elements: {e}")
-        
+
         return elements
 
 
@@ -1130,8 +1130,8 @@ class JavaPlugin(LanguagePlugin):
         """Initialize the Java plugin"""
         super().__init__()
         self._language_cache: tree_sitter.Language | None = None
-        self._extractor: Optional[JavaElementExtractor] = None
-        
+        self._extractor: JavaElementExtractor | None = None
+
         # Legacy attributes for backward compatibility with tests
         self.language = "java"
         self.extractor = self.create_extractor()
@@ -1191,21 +1191,23 @@ class JavaPlugin(LanguagePlugin):
             "supported_queries": self.get_supported_queries(),
         }
 
-    def execute_query_strategy(self, tree: "tree_sitter.Tree", source_code: str, query_key: str) -> list[dict]:
+    def execute_query_strategy(
+        self, tree: "tree_sitter.Tree", source_code: str, query_key: str
+    ) -> list[dict]:
         """
         Execute query strategy for Java language
-        
+
         Args:
             tree: Tree-sitter tree object
             source_code: Source code string
             query_key: Query key to execute
-            
+
         Returns:
             List of query results
         """
         # Use the extractor to get elements based on query_key
         extractor = self.get_extractor()
-        
+
         # Map query keys to extraction methods
         if query_key in ["method", "methods", "function", "functions"]:
             elements = extractor.extract_functions(tree, source_code)
@@ -1222,7 +1224,7 @@ class JavaPlugin(LanguagePlugin):
         else:
             # For unknown query keys, return empty list
             return []
-        
+
         # Convert elements to query result format
         results = []
         for element in elements:
@@ -1235,15 +1237,19 @@ class JavaPlugin(LanguagePlugin):
                 "name": element.name,
             }
             results.append(result)
-        
+
         return results
-    
+
     def _get_node_type_for_element(self, element) -> str:
         """Get appropriate node type for element"""
-        from ..models import Function, Class, Variable, Import, Package
-        
+        from ..models import Class, Function, Import, Package, Variable
+
         if isinstance(element, Function):
-            return "method_declaration" if not element.is_constructor else "constructor_declaration"
+            return (
+                "method_declaration"
+                if not element.is_constructor
+                else "constructor_declaration"
+            )
         elif isinstance(element, Class):
             if element.class_type == "interface":
                 return "interface_declaration"
@@ -1263,7 +1269,7 @@ class JavaPlugin(LanguagePlugin):
     def get_element_categories(self) -> dict[str, list[str]]:
         """
         Get element categories mapping query keys to node types
-        
+
         Returns:
             Dictionary mapping query keys to lists of node types
         """
@@ -1273,7 +1279,6 @@ class JavaPlugin(LanguagePlugin):
             "methods": ["method_declaration"],
             "constructor": ["constructor_declaration"],
             "constructors": ["constructor_declaration"],
-            
             # Class-related queries
             "class": ["class_declaration"],
             "classes": ["class_declaration"],
@@ -1281,29 +1286,30 @@ class JavaPlugin(LanguagePlugin):
             "interfaces": ["interface_declaration"],
             "enum": ["enum_declaration"],
             "enums": ["enum_declaration"],
-            
             # Field-related queries
             "field": ["field_declaration"],
             "fields": ["field_declaration"],
-            
             # Import-related queries
             "import": ["import_declaration"],
             "imports": ["import_declaration"],
-            
             # Package-related queries
             "package": ["package_declaration"],
             "packages": ["package_declaration"],
-            
             # Annotation-related queries
             "annotation": ["annotation", "marker_annotation"],
             "annotations": ["annotation", "marker_annotation"],
-            
             # Generic queries
             "all_elements": [
-                "method_declaration", "constructor_declaration",
-                "class_declaration", "interface_declaration", "enum_declaration",
-                "field_declaration", "import_declaration", "package_declaration",
-                "annotation", "marker_annotation"
+                "method_declaration",
+                "constructor_declaration",
+                "class_declaration",
+                "interface_declaration",
+                "enum_declaration",
+                "field_declaration",
+                "import_declaration",
+                "package_declaration",
+                "annotation",
+                "marker_annotation",
             ],
         }
 
@@ -1422,7 +1428,9 @@ class JavaPlugin(LanguagePlugin):
                 error_message=str(e),
             )
 
-    def extract_elements(self, tree: "tree_sitter.Tree", source_code: str) -> dict[str, list[CodeElement]]:
+    def extract_elements(
+        self, tree: "tree_sitter.Tree", source_code: str
+    ) -> dict[str, list[CodeElement]]:
         """Legacy method for backward compatibility with tests"""
         if not tree or not tree.root_node:
             return {
@@ -1431,11 +1439,11 @@ class JavaPlugin(LanguagePlugin):
                 "classes": [],
                 "variables": [],
                 "imports": [],
-                "annotations": []
+                "annotations": [],
             }
-        
+
         extractor = self.create_extractor()
-        
+
         # Extract all types of elements and return as dictionary
         result = {
             "packages": extractor.extract_packages(tree, source_code),
@@ -1443,7 +1451,7 @@ class JavaPlugin(LanguagePlugin):
             "classes": extractor.extract_classes(tree, source_code),
             "variables": extractor.extract_variables(tree, source_code),
             "imports": extractor.extract_imports(tree, source_code),
-            "annotations": extractor.extract_annotations(tree, source_code)
+            "annotations": extractor.extract_annotations(tree, source_code),
         }
-        
+
         return result