tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/queries/kotlin.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""
+Kotlin Language Queries
+
+Tree-sitter queries specific to Kotlin language constructs.
+Covers classes, functions, properties, interfaces, and other Kotlin-specific elements.
+"""
+
+# Kotlin-specific query library
+KOTLIN_QUERIES: dict[str, str] = {
+    # --- Basic Structure ---
+    "package": """
+    (package_header) @package
+    """,
+    "class": """
+    (class_declaration) @class
+    """,
+    "object": """
+    (object_declaration) @object
+    """,
+    "interface": """
+    (class_declaration
+      (#match? @class "interface")) @interface
+    """,
+    # --- Functions ---
+    "function": """
+    (function_declaration) @function
+    """,
+    "lambda": """
+    (lambda_literal) @lambda
+    """,
+    # --- Properties and Variables ---
+    "property": """
+    (property_declaration) @property
+    """,
+    "val": """
+    (property_declaration
+      (#match? @property "^val")) @val
+    """,
+    "var": """
+    (property_declaration
+      (#match? @property "^var")) @var
+    """,
+    # --- Annotations ---
+    "annotation": """
+    (annotation) @annotation
+    """,
+    # --- Detailed Queries ---
+    "class_with_body": """
+    (class_declaration
+      (simple_identifier) @name
+      (class_body) @body) @class_with_body
+    """,
+    "function_with_body": """
+    (function_declaration
+      (simple_identifier) @name
+      (function_body) @body) @function_with_body
+    """,
+    # --- Modifiers ---
+    "data_class": """
+    (class_declaration
+      (modifiers "data")
+      (simple_identifier) @name) @data_class
+    """,
+    "sealed_class": """
+    (class_declaration
+      (modifiers "sealed")
+      (simple_identifier) @name) @sealed_class
+    """,
+    "suspend_function": """
+    (function_declaration
+      (modifiers "suspend")
+      (simple_identifier) @name) @suspend_function
+    """,
+    # --- Names ---
+    "class_name": """
+    (class_declaration
+      (simple_identifier) @class_name)
+    """,
+    "function_name": """
+    (function_declaration
+      (simple_identifier) @function_name)
+    """,
+}
+
+# Query descriptions
+KOTLIN_QUERY_DESCRIPTIONS: dict[str, str] = {
+    "package": "Extract Kotlin package header",
+    "class": "Extract Kotlin class declarations",
+    "object": "Extract Kotlin object declarations",
+    "interface": "Extract Kotlin interface declarations",
+    "function": "Extract Kotlin function declarations",
+    "lambda": "Extract Kotlin lambda literals",
+    "property": "Extract Kotlin property declarations",
+    "val": "Extract Kotlin read-only properties (val)",
+    "var": "Extract Kotlin mutable properties (var)",
+    "annotation": "Extract Kotlin annotations",
+    "class_with_body": "Extract class declarations with body",
+    "function_with_body": "Extract function declarations with body",
+    "data_class": "Extract data classes",
+    "sealed_class": "Extract sealed classes",
+    "suspend_function": "Extract suspend functions",
+    "class_name": "Extract class names only",
+    "function_name": "Extract function names only",
+}
+
+
+def get_kotlin_query(name: str) -> str:
+    """
+    Get the specified Kotlin query
+
+    Args:
+        name: Query name
+
+    Returns:
+        Query string
+
+    Raises:
+        ValueError: When query is not found
+    """
+    if name not in KOTLIN_QUERIES:
+        available = list(KOTLIN_QUERIES.keys())
+        raise ValueError(
+            f"Kotlin query '{name}' does not exist. Available: {available}"
+        )
+
+    return KOTLIN_QUERIES[name]
+
+
+def get_kotlin_query_description(name: str) -> str:
+    """
+    Get the description of the specified Kotlin query
+
+    Args:
+        name: Query name
+
+    Returns:
+        Query description
+    """
+    return KOTLIN_QUERY_DESCRIPTIONS.get(name, "No description")
+
+
+# Convert to ALL_QUERIES format for dynamic loader compatibility
+ALL_QUERIES = {}
+for query_name, query_string in KOTLIN_QUERIES.items():
+    description = KOTLIN_QUERY_DESCRIPTIONS.get(query_name, "No description")
+    ALL_QUERIES[query_name] = {"query": query_string, "description": description}
+
+# Add common query aliases for cross-language compatibility
+ALL_QUERIES["functions"] = {
+    "query": KOTLIN_QUERIES["function"],
+    "description": "Search all function declarations (alias for function)",
+}
+
+ALL_QUERIES["methods"] = {
+    "query": KOTLIN_QUERIES["function"],
+    "description": "Search all function declarations (alias for function)",
+}
+
+ALL_QUERIES["classes"] = {
+    "query": KOTLIN_QUERIES["class"],
+    "description": "Search all class declarations (alias for class)",
+}
+
+
+def get_query(name: str) -> str:
+    """Get a specific query by name."""
+    if name in ALL_QUERIES:
+        return ALL_QUERIES[name]["query"]
+    raise ValueError(
+        f"Query '{name}' not found. Available queries: {list(ALL_QUERIES.keys())}"
+    )
+
+
+def get_all_queries() -> dict:
+    """Get all available queries."""
+    return ALL_QUERIES
+
+
+def list_queries() -> list:
+    """List all available query names."""
+    return list(ALL_QUERIES.keys())
+
+
+def get_available_kotlin_queries() -> list[str]:
+    """
+    Get list of available Kotlin queries
+
+    Returns:
+        List of query names
+    """
+    return list(KOTLIN_QUERIES.keys())

tree_sitter_analyzer/queries/markdown.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+Markdown Query Definitions
+
+Tree-sitter queries for extracting Markdown elements including headers,
+links, code blocks, lists, and other structural elements.
+"""
+
+# Markdown element extraction queries - simplified for compatibility
+MARKDOWN_QUERIES: dict[str, str] = {
+    # Headers (H1-H6) - simplified
+    "headers": """
+    (atx_heading) @header
+    (setext_heading) @header
+    """,
+    # Code blocks - simplified
+    "code_blocks": """
+    (fenced_code_block) @code_block
+    (indented_code_block) @code_block
+    """,
+    # Inline code - simplified
+    "inline_code": """
+    (inline) @inline
+    """,
+    # Links - simplified to avoid invalid node types
+    "links": """
+    (inline) @inline
+    """,
+    # Images - simplified to avoid invalid node types
+    "images": """
+    (inline) @inline
+    """,
+    # Lists - simplified to avoid invalid node types
+    "lists": """
+    (list) @list
+    (list_item) @list_item
+    """,
+    # Emphasis and strong - simplified
+    "emphasis": """
+    (inline) @inline
+    """,
+    # Blockquotes - simplified
+    "blockquotes": """
+    (block_quote) @blockquote
+    """,
+    # Tables - simplified
+    "tables": """
+    (pipe_table) @table
+    """,
+    # Horizontal rules - simplified
+    "horizontal_rules": """
+    (thematic_break) @hr
+    """,
+    # HTML blocks - simplified
+    "html_blocks": """
+    (html_block) @html_block
+    """,
+    # Inline HTML - simplified
+    "inline_html": """
+    (inline) @inline
+    """,
+    # Strikethrough - simplified
+    "strikethrough": """
+    (inline) @inline
+    """,
+    # Task lists - simplified
+    "task_lists": """
+    (list_item) @list_item
+    """,
+    # Footnotes - simplified
+    "footnotes": """
+    (paragraph) @paragraph
+    (inline) @inline
+    """,
+    # All text content - simplified
+    "text_content": """
+    (paragraph) @paragraph
+    (inline) @inline
+    """,
+    # Document structure - simplified
+    "document": """
+    (document) @document
+    """,
+    # All elements (comprehensive) - simplified
+    "all_elements": """
+    (atx_heading) @heading
+    (setext_heading) @heading
+    (fenced_code_block) @code_block
+    (indented_code_block) @code_block
+    (inline) @inline
+    (list) @list
+    (list_item) @list_item
+    (block_quote) @blockquote
+    (pipe_table) @table
+    (thematic_break) @hr
+    (html_block) @html_block
+    (paragraph) @paragraph
+    (link_reference_definition) @reference
+    """,
+}
+
+# Query aliases for convenience
+QUERY_ALIASES: dict[str, str] = {
+    "heading": "headers",
+    "h1": "headers",
+    "h2": "headers",
+    "h3": "headers",
+    "h4": "headers",
+    "h5": "headers",
+    "h6": "headers",
+    "code": "code_blocks",
+    "fenced_code": "code_blocks",
+    "code_span": "inline_code",
+    "link": "links",
+    "url": "links",
+    "image": "images",
+    "img": "images",
+    "list": "lists",
+    "ul": "lists",
+    "ol": "lists",
+    "em": "emphasis",
+    "strong": "emphasis",
+    "bold": "emphasis",
+    "italic": "emphasis",
+    "quote": "blockquotes",
+    "blockquote": "blockquotes",
+    "table": "tables",
+    "hr": "horizontal_rules",
+    "html": "html_blocks",
+    "strike": "strikethrough",
+    "task": "task_lists",
+    "todo": "task_lists",
+    "footnote": "footnotes",
+    "note": "footnotes",
+    "text": "text_content",
+    "paragraph": "text_content",
+    "all": "all_elements",
+    "everything": "all_elements",
+}
+
+
+def get_query(query_name: str) -> str:
+    """
+    Get a query by name, supporting aliases
+
+    Args:
+        query_name: Name of the query or alias
+
+    Returns:
+        Query string
+
+    Raises:
+        KeyError: If query name is not found
+    """
+    # Check direct queries first
+    if query_name in MARKDOWN_QUERIES:
+        return MARKDOWN_QUERIES[query_name]
+
+    # Check aliases
+    if query_name in QUERY_ALIASES:
+        actual_query = QUERY_ALIASES[query_name]
+        return MARKDOWN_QUERIES[actual_query]
+
+    raise KeyError(f"Unknown query: {query_name}")
+
+
+def get_available_queries() -> list[str]:
+    """
+    Get list of all available query names including aliases
+
+    Returns:
+        List of query names
+    """
+    queries = list(MARKDOWN_QUERIES.keys())
+    aliases = list(QUERY_ALIASES.keys())
+    return sorted(queries + aliases)
+
+
+def get_query_info(query_name: str) -> dict[str, str | bool]:
+    """
+    Get information about a query
+
+    Args:
+        query_name: Name of the query
+
+    Returns:
+        Dictionary with query information
+    """
+    try:
+        query_string = get_query(query_name)
+        is_alias = query_name in QUERY_ALIASES
+        actual_name = (
+            QUERY_ALIASES.get(query_name, query_name) if is_alias else query_name
+        )
+
+        return {
+            "name": query_name,
+            "actual_name": actual_name,
+            "is_alias": is_alias,
+            "query": query_string,
+            "description": _get_query_description(actual_name),
+        }
+    except KeyError:
+        return {"error": f"Query '{query_name}' not found"}
+
+
+def _get_query_description(query_name: str) -> str:
+    """Get description for a query"""
+    descriptions = {
+        "headers": "Extract all heading elements (H1-H6, both ATX and Setext styles)",
+        "code_blocks": "Extract fenced and indented code blocks",
+        "inline_code": "Extract inline code spans",
+        "links": "Extract all types of links (inline, reference, autolinks)",
+        "images": "Extract image elements (inline and reference)",
+        "lists": "Extract ordered and unordered lists",
+        "emphasis": "Extract emphasis and strong emphasis elements",
+        "blockquotes": "Extract blockquote elements",
+        "tables": "Extract pipe table elements",
+        "horizontal_rules": "Extract horizontal rule elements",
+        "html_blocks": "Extract HTML block elements",
+        "inline_html": "Extract inline HTML elements",
+        "strikethrough": "Extract strikethrough elements",
+        "task_lists": "Extract task list items (checkboxes)",
+        "footnotes": "Extract footnote references and definitions",
+        "text_content": "Extract all text content",
+        "document": "Extract document root",
+        "all_elements": "Extract all Markdown elements",
+    }
+    return descriptions.get(query_name, "No description available")
+
+
+def get_all_queries() -> dict[str, str]:
+    """
+    Get all queries for the query loader
+
+    Returns:
+        Dictionary mapping query names to query strings
+    """
+    # Combine direct queries and aliases
+    all_queries = MARKDOWN_QUERIES.copy()
+
+    # Add aliases that point to actual queries
+    for alias, target in QUERY_ALIASES.items():
+        if target in MARKDOWN_QUERIES:
+            all_queries[alias] = MARKDOWN_QUERIES[target]
+
+    return all_queries
+
+
+# Export main functions and constants
+__all__ = [
+    "MARKDOWN_QUERIES",
+    "QUERY_ALIASES",
+    "get_query",
+    "get_available_queries",
+    "get_query_info",
+    "get_all_queries",
+]

tree_sitter_analyzer/queries/php.py

@@ -0,0 +1,95 @@
+"""
+PHP Tree-sitter Queries
+
+Defines tree-sitter queries for efficient PHP element extraction.
+"""
+
+# Query for PHP classes, interfaces, traits, and enums
+PHP_CLASS_QUERY = """
+(class_declaration
+  name: (name) @class.name) @class.definition
+
+(interface_declaration
+  name: (name) @interface.name) @interface.definition
+
+(trait_declaration
+  name: (name) @trait.name) @trait.definition
+
+(enum_declaration
+  name: (name) @enum.name) @enum.definition
+"""
+
+# Query for PHP methods
+PHP_METHOD_QUERY = """
+(method_declaration
+  name: (name) @method.name
+  parameters: (formal_parameters) @method.parameters) @method.definition
+"""
+
+# Query for PHP functions
+PHP_FUNCTION_QUERY = """
+(function_definition
+  name: (name) @function.name
+  parameters: (formal_parameters) @function.parameters) @function.definition
+"""
+
+# Query for PHP properties
+PHP_PROPERTY_QUERY = """
+(property_declaration
+  (property_element
+    (variable_name) @property.name)) @property.definition
+"""
+
+# Query for PHP constants
+PHP_CONSTANT_QUERY = """
+(const_declaration
+  (const_element
+    name: (name) @constant.name)) @constant.definition
+"""
+
+# Query for PHP use statements
+PHP_USE_QUERY = """
+(namespace_use_declaration
+  (namespace_use_clause
+    (qualified_name) @import.name)) @import.definition
+"""
+
+# Query for PHP namespaces
+PHP_NAMESPACE_QUERY = """
+(namespace_definition
+  name: (namespace_name) @namespace.name) @namespace.definition
+"""
+
+# Query for PHP attributes (PHP 8+)
+PHP_ATTRIBUTE_QUERY = """
+(attribute_list
+  (attribute_group
+    (attribute
+      name: (name) @attribute.name))) @attribute.definition
+"""
+
+# Query for PHP magic methods
+PHP_MAGIC_METHOD_QUERY = """
+(method_declaration
+  name: (name) @magic.method.name
+  (#match? @magic.method.name "^__")) @magic.method.definition
+"""
+
+# Combined query for all PHP elements
+PHP_ALL_ELEMENTS_QUERY = f"""
+{PHP_CLASS_QUERY}
+
+{PHP_METHOD_QUERY}
+
+{PHP_FUNCTION_QUERY}
+
+{PHP_PROPERTY_QUERY}
+
+{PHP_CONSTANT_QUERY}
+
+{PHP_USE_QUERY}
+
+{PHP_NAMESPACE_QUERY}
+
+{PHP_ATTRIBUTE_QUERY}
+"""