tree-sitter-analyzer 1.7.5__py3-none-any.whl → 1.8.2__py3-none-any.whl

tree_sitter_analyzer/languages/html_plugin.py

@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+"""
+HTML Language Plugin
+
+True HTML parser using tree-sitter-html for comprehensive HTML analysis.
+Provides HTML-specific analysis capabilities including element extraction,
+attribute parsing, and document structure analysis.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from ..models import AnalysisResult, MarkupElement
+from ..plugins.base import ElementExtractor, LanguagePlugin
+from ..utils import log_debug, log_error, log_info
+
+if TYPE_CHECKING:
+    import tree_sitter
+
+    from ..core.analysis_engine import AnalysisRequest
+
+logger = logging.getLogger(__name__)
+
+
+class HtmlElementExtractor(ElementExtractor):
+    """HTML-specific element extractor using tree-sitter-html"""
+
+    def __init__(self):
+        self.element_categories = {
+            # HTML要素の分類システム
+            "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"],
+            "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"]
+        }
+
+    def extract_functions(self, tree: "tree_sitter.Tree", source_code: str) -> list:
+        """HTML doesn't have functions, return empty list"""
+        return []
+
+    def extract_classes(self, tree: "tree_sitter.Tree", source_code: str) -> list:
+        """HTML doesn't have classes in the traditional sense, return empty list"""
+        return []
+
+    def extract_variables(self, tree: "tree_sitter.Tree", source_code: str) -> list:
+        """HTML doesn't have variables, return empty list"""
+        return []
+
+    def extract_imports(self, tree: "tree_sitter.Tree", source_code: str) -> list:
+        """HTML doesn't have imports, return empty list"""
+        return []
+
+    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)
+        except Exception as e:
+            log_error(f"Error in HTML element extraction: {e}")
+
+        return elements
+
+    def _traverse_for_html_elements(
+        self,
+        node: "tree_sitter.Node",
+        elements: list[MarkupElement],
+        source_code: str,
+        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):
+            try:
+                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)
+                    return
+            except Exception as e:
+                log_debug(f"Failed to extract HTML element: {e}")
+
+        # Continue traversing children if this node is not an HTML element
+        if hasattr(node, "children"):
+            for child in node.children:
+                self._traverse_for_html_elements(child, elements, source_code, parent)
+
+    def _is_html_element_node(self, node_type: str) -> bool:
+        """Check if a node type represents an HTML element in tree-sitter-html grammar"""
+        html_element_types = [
+            "element",
+            "start_tag",
+            "self_closing_tag",
+            "script_element",
+            "style_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
+    ) -> MarkupElement | None:
+        """Create MarkupElement from tree-sitter node using tree-sitter-html grammar"""
+        try:
+            # Extract tag name using tree-sitter-html structure
+            tag_name = self._extract_tag_name(node, source_code)
+            if not tag_name:
+                return None
+
+            # Extract attributes using tree-sitter-html structure
+            attributes = self._extract_attributes(node, source_code)
+
+            # Determine element class based on tag name
+            element_class = self._classify_element(tag_name)
+
+            # Extract text content
+            raw_text = self._extract_node_text(node, source_code)
+
+            # Create MarkupElement
+            element = MarkupElement(
+                name=tag_name,
+                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",
+                tag_name=tag_name,
+                attributes=attributes,
+                parent=parent,
+                children=[],
+                element_class=element_class
+            )
+
+            # Add to parent's children if parent exists
+            if parent:
+                parent.children.append(element)
+
+            return element
+
+        except Exception as e:
+            log_debug(f"Failed to create MarkupElement: {e}")
+            return None
+
+    def _extract_tag_name(self, node: "tree_sitter.Node", source_code: str) -> str:
+        """Extract tag name from HTML element node using tree-sitter-html grammar"""
+        try:
+            # For tree-sitter-html, tag names are in specific child nodes
+            if hasattr(node, "children"):
+                for child in node.children:
+                    if hasattr(child, "type"):
+                        # Handle different node types in tree-sitter-html
+                        if child.type == "tag_name":
+                            return self._extract_node_text(child, source_code).strip()
+                        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()
+            
+            # 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]:
+        """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)
+                            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 attr_name:
+                                        attributes[attr_name] = attr_value
+        except Exception as e:
+            log_debug(f"Failed to extract attributes: {e}")
+
+        return attributes
+
+    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()
+                        elif child.type == "quoted_attribute_value":
+                            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()
+            
+            # Fallback to simple parsing
+            if not attr_name:
+                attr_text = self._extract_node_text(attr_node, source_code)
+                if "=" in attr_text:
+                    name, value = attr_text.split("=", 1)
+                    attr_name = name.strip()
+                    attr_value = value.strip().strip('"').strip("'")
+                else:
+                    # Boolean attribute
+                    attr_name = attr_text.strip()
+                    attr_value = ""
+            
+            return attr_name, attr_value
+        except Exception:
+            return "", ""
+
+    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:
+        """Extract text content from a tree-sitter node"""
+        try:
+            if hasattr(node, "start_byte") and hasattr(node, "end_byte"):
+                source_bytes = source_code.encode("utf-8")
+                node_bytes = source_bytes[node.start_byte : node.end_byte]
+                return node_bytes.decode("utf-8", errors="replace")
+            return ""
+        except Exception as e:
+            log_debug(f"Failed to extract node text: {e}")
+            return ""
+
+
+class HtmlPlugin(LanguagePlugin):
+    """HTML language plugin using tree-sitter-html for true HTML parsing"""
+
+    def get_language_name(self) -> str:
+        return "html"
+
+    def get_file_extensions(self) -> list[str]:
+        return [".html", ".htm", ".xhtml"]
+
+    def create_extractor(self) -> ElementExtractor:
+        return HtmlElementExtractor()
+
+    def get_supported_element_types(self) -> list[str]:
+        return ["html_element"]
+
+    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:
+        """Execute query strategy for HTML"""
+        if language != "html":
+            return None
+        
+        queries = self.get_queries()
+        return queries.get(query_key) if query_key else None
+
+    def get_element_categories(self) -> dict[str, list[str]]:
+        """Return HTML element categories for query execution"""
+        return {
+            "structure": ["element"],
+            "heading": ["element"],
+            "text": ["element"],
+            "list": ["element"],
+            "media": ["element"],
+            "form": ["element"],
+            "table": ["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
+                
+                # 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'))
+                
+                # 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",
+                    line_count=len(content.splitlines()),
+                    elements=elements,
+                    node_count=len(elements),
+                    query_results={},
+                    source_code=content,
+                    success=True,
+                    error_message=None
+                )
+                
+            except ImportError:
+                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",
+                    start_line=1,
+                    end_line=line_count,
+                    raw_text=content[:200] + "..." if len(content) > 200 else content,
+                    language="html",
+                    tag_name="html",
+                    attributes={},
+                    parent=None,
+                    children=[],
+                    element_class="structure"
+                )
+                elements = [html_element]
+
+                return AnalysisResult(
+                    file_path=file_path,
+                    language="html",
+                    line_count=line_count,
+                    elements=elements,
+                    node_count=len(elements),
+                    query_results={},
+                    source_code=content,
+                    success=True,
+                    error_message=None
+                )
+
+        except Exception as e:
+            log_error(f"Failed to analyze HTML file {file_path}: {e}")
+            return AnalysisResult(
+                file_path=file_path,
+                language="html",
+                line_count=0,
+                elements=[],
+                node_count=0,
+                query_results={},
+                source_code="",
+                success=False,
+                error_message=str(e)
+            )

tree_sitter_analyzer/languages/java_plugin.py

@@ -1191,6 +1191,122 @@ 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]:
+        """
+        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)
+        elif query_key in ["class", "classes"]:
+            elements = extractor.extract_classes(tree, source_code)
+        elif query_key in ["field", "fields", "variable", "variables"]:
+            elements = extractor.extract_variables(tree, source_code)
+        elif query_key in ["import", "imports"]:
+            elements = extractor.extract_imports(tree, source_code)
+        elif query_key in ["package", "packages"]:
+            elements = extractor.extract_packages(tree, source_code)
+        elif query_key in ["annotation", "annotations"]:
+            elements = extractor.extract_annotations(tree, source_code)
+        else:
+            # For unknown query keys, return empty list
+            return []
+        
+        # Convert elements to query result format
+        results = []
+        for element in elements:
+            result = {
+                "capture_name": query_key,
+                "node_type": self._get_node_type_for_element(element),
+                "start_line": element.start_line,
+                "end_line": element.end_line,
+                "text": element.raw_text,
+                "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
+        
+        if isinstance(element, Function):
+            return "method_declaration" if not element.is_constructor else "constructor_declaration"
+        elif isinstance(element, Class):
+            if element.class_type == "interface":
+                return "interface_declaration"
+            elif element.class_type == "enum":
+                return "enum_declaration"
+            else:
+                return "class_declaration"
+        elif isinstance(element, Variable):
+            return "field_declaration"
+        elif isinstance(element, Import):
+            return "import_declaration"
+        elif isinstance(element, Package):
+            return "package_declaration"
+        else:
+            return "unknown"
+
+    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
+        """
+        return {
+            # Method-related queries
+            "method": ["method_declaration"],
+            "methods": ["method_declaration"],
+            "constructor": ["constructor_declaration"],
+            "constructors": ["constructor_declaration"],
+            
+            # Class-related queries
+            "class": ["class_declaration"],
+            "classes": ["class_declaration"],
+            "interface": ["interface_declaration"],
+            "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"
+            ],
+        }
+
     async def analyze_file(
         self, file_path: str, request: "AnalysisRequest"
     ) -> "AnalysisResult":

tree_sitter_analyzer/languages/javascript_plugin.py

@@ -1440,6 +1440,119 @@ class JavaScriptPlugin(LanguagePlugin):
             ],
         }
 
+    def execute_query_strategy(self, tree: "tree_sitter.Tree", source_code: str, query_key: str) -> list[dict]:
+        """
+        Execute query strategy for JavaScript 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 ["function", "functions", "async_function", "async_functions", "arrow_function", "arrow_functions", "method", "methods", "constructor", "constructors"]:
+            elements = extractor.extract_functions(tree, source_code)
+        elif query_key in ["class", "classes", "react_component", "react_components"]:
+            elements = extractor.extract_classes(tree, source_code)
+        elif query_key in ["variable", "variables"]:
+            elements = extractor.extract_variables(tree, source_code)
+        elif query_key in ["import", "imports"]:
+            elements = extractor.extract_imports(tree, source_code)
+        else:
+            # For unknown query keys, return empty list
+            return []
+        
+        # Convert elements to query result format
+        results = []
+        for element in elements:
+            result = {
+                "capture_name": query_key,
+                "node_type": self._get_node_type_for_element(element),
+                "start_line": element.start_line,
+                "end_line": element.end_line,
+                "text": element.raw_text,
+                "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
+        
+        if isinstance(element, Function):
+            if hasattr(element, 'is_arrow') and element.is_arrow:
+                return "arrow_function"
+            elif hasattr(element, 'is_method') and element.is_method:
+                return "method_definition"
+            else:
+                return "function_declaration"
+        elif isinstance(element, Class):
+            return "class_declaration"
+        elif isinstance(element, Variable):
+            return "variable_declaration"
+        elif isinstance(element, Import):
+            return "import_statement"
+        else:
+            return "unknown"
+
+    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
+        """
+        return {
+            # Function-related queries
+            "function": ["function_declaration", "function_expression"],
+            "functions": ["function_declaration", "function_expression"],
+            "async_function": ["function_declaration", "function_expression"],
+            "async_functions": ["function_declaration", "function_expression"],
+            "arrow_function": ["arrow_function"],
+            "arrow_functions": ["arrow_function"],
+            "method": ["method_definition"],
+            "methods": ["method_definition"],
+            "constructor": ["method_definition"],
+            "constructors": ["method_definition"],
+            
+            # Class-related queries
+            "class": ["class_declaration", "class_expression"],
+            "classes": ["class_declaration", "class_expression"],
+            
+            # Variable-related queries
+            "variable": ["variable_declaration", "lexical_declaration"],
+            "variables": ["variable_declaration", "lexical_declaration"],
+            
+            # Import/Export-related queries
+            "import": ["import_statement"],
+            "imports": ["import_statement"],
+            "export": ["export_statement"],
+            "exports": ["export_statement"],
+            
+            # React-specific queries
+            "react_component": ["class_declaration", "function_declaration"],
+            "react_components": ["class_declaration", "function_declaration"],
+            "react_hook": ["function_declaration"],
+            "react_hooks": ["function_declaration"],
+            "jsx_element": ["jsx_element", "jsx_self_closing_element"],
+            "jsx_elements": ["jsx_element", "jsx_self_closing_element"],
+            
+            # Generic queries
+            "all_elements": [
+                "function_declaration", "function_expression", "arrow_function", "method_definition",
+                "class_declaration", "class_expression", "variable_declaration", "lexical_declaration",
+                "import_statement", "export_statement", "jsx_element", "jsx_self_closing_element"
+            ],
+        }
+
     async def analyze_file(
         self, file_path: str, request: AnalysisRequest
     ) -> AnalysisResult: