tree-sitter-analyzer 1.9.1__py3-none-any.whl → 1.9.3__py3-none-any.whl

tree_sitter_analyzer/language_detector.py

@@ -321,9 +321,6 @@ class LanguageDetector:
             if not language or language.strip() == "":
                 return "unknown"
             return language
-        else:
-            # Fallback for unexpected result format
-            return "unknown"
 
     def is_supported(self, language: str) -> bool:
         """
@@ -335,7 +332,21 @@ class LanguageDetector:
         Returns:
             Support status
         """
-        return language in self.SUPPORTED_LANGUAGES
+        # First check the static list for basic support
+        if language in self.SUPPORTED_LANGUAGES:
+            return True
+
+        # Also check if we have a plugin for this language
+        try:
+            from .plugins.manager import PluginManager
+
+            plugin_manager = PluginManager()
+            plugin_manager.load_plugins()  # Ensure plugins are loaded
+            supported_languages = plugin_manager.get_supported_languages()
+            return language in supported_languages
+        except Exception:
+            # Fallback to static list if plugin manager fails
+            return language in self.SUPPORTED_LANGUAGES
 
     def get_supported_extensions(self) -> list[str]:
         """
@@ -509,4 +520,18 @@ def is_language_supported(language: str) -> bool:
     Returns:
         Support status
     """
-    return detector.is_supported(language)
+    # First check the static list for basic support
+    if detector.is_supported(language):
+        return True
+
+    # Also check if we have a plugin for this language
+    try:
+        from .plugins.manager import PluginManager
+
+        plugin_manager = PluginManager()
+        plugin_manager.load_plugins()  # Ensure plugins are loaded
+        supported_languages = plugin_manager.get_supported_languages()
+        return language in supported_languages
+    except Exception:
+        # Fallback to static list if plugin manager fails
+        return detector.is_supported(language)

tree_sitter_analyzer/language_loader.py

@@ -92,7 +92,7 @@ class LanguageLoader:
             self._unavailable_languages.add(language)
             return False
 
-    def load_language(self, language: str) -> Optional["Language"]:
+    def load_language(self, language: str) -> Any | None:
         """Load and return a tree-sitter Language object for the specified language"""
         if not TREE_SITTER_AVAILABLE:
             log_warning("Tree-sitter is not available")
@@ -131,16 +131,27 @@ class LanguageLoader:
                 else:
                     return None
 
-            # Language オブジェクト作成（互換性対応）
+            # Language オブジェクト作成（新しいAPI対応）
             caps_or_lang = language_func()
-            try:
-                tree_sitter_language = tree_sitter.Language(caps_or_lang)
-            except Exception:
-                # 一部のパッケージは既に Language オブジェクトを返すため、そのまま使用
-                tree_sitter_language = caps_or_lang  # type: ignore[assignment]
 
-            self._loaded_languages[language] = tree_sitter_language  # type: ignore[assignment]
-            return tree_sitter_language  # type: ignore[return-value]
+            # 新しいtree-sitter APIでは、language_func()が直接Languageオブジェクトを返す
+            # 古いAPIではPyCapsuleを返すため、適切に処理する
+            if hasattr(caps_or_lang, "__class__") and "Language" in str(
+                type(caps_or_lang)
+            ):
+                # 既にLanguageオブジェクトの場合はそのまま使用
+                tree_sitter_language = caps_or_lang
+            else:
+                # PyCapsuleの場合は、Languageオブジェクトを作成
+                try:
+                    # Use modern tree-sitter API - PyCapsule should be passed to Language constructor
+                    tree_sitter_language = tree_sitter.Language(caps_or_lang)
+                except Exception as e:
+                    log_warning(f"Failed to create Language object for {language}: {e}")
+                    return None
+
+            self._loaded_languages[language] = tree_sitter_language
+            return tree_sitter_language
 
         except (ImportError, AttributeError, Exception) as e:
             log_warning(f"Failed to load language '{language}': {e}")
@@ -162,23 +173,32 @@ class LanguageLoader:
             return None
 
         try:
-            # Prefer constructor with language for environments that require it
-            try:
-                parser = tree_sitter.Parser(tree_sitter_language)
-            except Exception:
-                # Fallback to no-arg constructor with setter for newer APIs
-                parser = tree_sitter.Parser()
-                if hasattr(parser, "set_language"):
-                    parser.set_language(tree_sitter_language)
-                elif hasattr(parser, "language"):
-                    try:
-                        parser.language = tree_sitter_language
-                    except Exception as inner_e:  # noqa: F841
-                        raise
-                else:
-                    raise RuntimeError(
-                        "Unsupported Parser API: no way to set language"
-                    ) from None
+            # Create parser and set language properly
+            parser = tree_sitter.Parser()
+
+            # Ensure we have a proper Language object
+            if not hasattr(tree_sitter_language, "__class__") or "Language" not in str(
+                type(tree_sitter_language)
+            ):
+                log_warning(
+                    f"Invalid language object for {language}: {type(tree_sitter_language)}"
+                )
+                return None
+
+            # Set language using the preferred method
+            if hasattr(parser, "set_language"):
+                parser.set_language(tree_sitter_language)
+            elif hasattr(parser, "language"):
+                parser.language = tree_sitter_language
+            else:
+                # Try constructor approach as last resort
+                try:
+                    parser = tree_sitter.Parser(tree_sitter_language)
+                except Exception as e:
+                    log_warning(
+                        f"Failed to create parser with language constructor for {language}: {e}"
+                    )
+                    return None
 
             # Cache and return
             self._parser_cache[language] = parser

tree_sitter_analyzer/languages/css_plugin.py

@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 class CssElementExtractor(ElementExtractor):
     """CSS-specific element extractor using tree-sitter-css"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.property_categories = {
             # CSS プロパティの分類システム
             "layout": [
@@ -100,7 +100,7 @@ class CssElementExtractor(ElementExtractor):
         self, tree: "tree_sitter.Tree", source_code: str
     ) -> list[StyleElement]:
         """Extract CSS rules using tree-sitter-css parser"""
-        elements = []
+        elements: list[StyleElement] = []
 
         try:
             if hasattr(tree, "root_node"):
@@ -176,9 +176,9 @@ class CssElementExtractor(ElementExtractor):
             # Create StyleElement
             element = StyleElement(
                 name=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="css",
@@ -296,7 +296,7 @@ class CssElementExtractor(ElementExtractor):
                     category_scores[category] += 1
 
         # Return category with highest score
-        best_category = max(category_scores, key=category_scores.get)
+        best_category = max(category_scores, key=lambda k: category_scores[k])
         return best_category if category_scores[best_category] > 0 else "other"
 
     def _extract_node_text(self, node: "tree_sitter.Node", source_code: str) -> str:

tree_sitter_analyzer/languages/html_plugin.py

@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 class HtmlElementExtractor(ElementExtractor):
     """HTML-specific element extractor using tree-sitter-html"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.element_categories = {
             # HTML要素の分類システム
             "structure": [
@@ -124,7 +124,7 @@ class HtmlElementExtractor(ElementExtractor):
         self, tree: "tree_sitter.Tree", source_code: str
     ) -> list[MarkupElement]:
         """Extract HTML elements using tree-sitter-html parser"""
-        elements = []
+        elements: list[MarkupElement] = []
 
         try:
             if hasattr(tree, "root_node"):
@@ -167,18 +167,22 @@ class HtmlElementExtractor(ElementExtractor):
 
     def _is_html_element_node(self, node_type: str) -> bool:
         """Check if a node type represents an HTML element in tree-sitter-html grammar"""
+        # Only process top-level element nodes to avoid duplication
+        # tree-sitter-html structure: element contains start_tag/end_tag
+        # Processing only 'element' avoids counting start_tag separately
         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
+        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:
@@ -199,9 +203,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",