codedebrief 0.11.0__py3-none-any.whl

codedebrief/analysis/languages/java.py

@@ -0,0 +1,158 @@
+"""Java language profile for the profile-driven tree-sitter analyzer."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import tree_sitter_java
+
+from codedebrief.analysis.common import DEFAULT as DEFAULT_LABEL
+from codedebrief.analysis.languages._common import container_definitions, module_name, named, text
+from codedebrief.analysis.treesitter import (
+    CaseInfo,
+    LanguageProfile,
+    TreeSitterAnalyzer,
+    TSDefinition,
+)
+from codedebrief.config import CodeDebriefConfig
+
+_CONTAINERS = frozenset(
+    {"class_declaration", "interface_declaration", "enum_declaration", "record_declaration"}
+)
+_METHODS = frozenset({"method_declaration", "constructor_declaration"})
+_ROUTE_ANNOTATIONS = (
+    "@GetMapping",
+    "@PostMapping",
+    "@PutMapping",
+    "@DeleteMapping",
+    "@PatchMapping",
+    "@RequestMapping",
+)
+
+
+def _modifiers(node: Any, source: bytes) -> str:
+    for child in node.children:
+        if child.type == "modifiers":
+            return text(child, source)
+    return ""
+
+
+def _classify(
+    definition: TSDefinition, relative: str, source: str, config: CodeDebriefConfig
+) -> tuple[str, str, bool]:
+    override = config.entrypoint_override(f"{relative}:{definition.owner}.{definition.name}")
+    modifiers = _modifiers(definition.node, source.encode("utf-8"))
+    if definition.name == "main" and "static" in modifiers:
+        return "java", "main", override if override is not None else True
+    if any(annotation in modifiers for annotation in _ROUTE_ANNOTATIONS):
+        return "spring", "route", override if override is not None else True
+    public = config.include_public_functions and "public" in modifiers
+    return "generic", "method", override if override is not None else public
+
+
+def _is_test(relative: str, name: str) -> bool:
+    # Maven/Gradle put tests under a `test` source-set segment; the class file is
+    # *Test.java / *Tests.java / *IT.java. A bare `test`-prefixed METHOD name
+    # (`testConnection` in a production class) is a real method, so it must not classify.
+    segments = relative.split("/")
+    return any(segment == "test" for segment in segments[:-1]) or segments[-1].endswith(
+        ("Test.java", "Tests.java", "IT.java")
+    )
+
+
+def _import_map(root: Any, source: bytes, relative: str) -> dict[str, str]:
+    mapping: dict[str, str] = {}
+    for declaration in root.children:
+        if declaration.type != "import_declaration":
+            continue
+        specifier = _import_specifier(declaration, source)
+        if not specifier:
+            continue
+        is_static = any(child.type == "static" for child in declaration.children)
+        is_wildcard = any(child.type == "asterisk" for child in declaration.children)
+        if is_wildcard:
+            mapping[f"__wildcard_import__:{specifier}"] = f"{specifier}:"
+            continue
+        if is_static:
+            owner, _, member = specifier.rpartition(".")
+            package, _, class_name = owner.rpartition(".")
+            if package and class_name and member:
+                mapping[member] = f"{package}:{class_name}.{member}"
+                mapping[f"__dependency_import__:{owner}"] = f"{owner}:"
+            continue
+        package, _, class_name = specifier.rpartition(".")
+        if package and class_name:
+            mapping[class_name] = f"{package}:{class_name}"
+            mapping[f"__dependency_import__:{specifier}"] = f"{specifier}:"
+    return mapping
+
+
+def _import_specifier(declaration: Any, source: bytes) -> str:
+    for child in declaration.children:
+        if child.type in {"scoped_identifier", "identifier"}:
+            return text(child, source)
+    return ""
+
+
+def _switch_cases(switch_node: Any, source: bytes, profile: LanguageProfile) -> list[CaseInfo]:
+    body = switch_node.child_by_field_name("body")
+    cases: list[CaseInfo] = []
+    for group in named(body):
+        if group.type != "switch_block_statement_group":
+            continue
+        labels = [c for c in named(group) if c.type == "switch_label"]
+        statements = [c for c in named(group) if c.type != "switch_label"]
+        values: list[str] = []
+        is_default = False
+        for label in labels:
+            value = next(iter(named(label)), None)
+            if value is None:
+                is_default = True
+            else:
+                values.append(text(value, source))
+        if is_default and not values:
+            cases.append(CaseInfo(DEFAULT_LABEL, True, [], statements))
+        else:
+            cases.append(CaseInfo(", ".join(values) or "case", False, values, statements))
+    return cases
+
+
+def _call_name(call: Any, source: bytes) -> str:
+    if call.type == "method_invocation":
+        return text(call.child_by_field_name("name"), source)
+    if call.type == "object_creation_expression":
+        return text(call.child_by_field_name("type"), source)
+    return ""
+
+
+JAVA_PROFILE = LanguageProfile(
+    language="java",
+    grammar_loader=tree_sitter_java.language,
+    function_types=_METHODS,
+    definitions=container_definitions(_CONTAINERS, _METHODS),
+    classify=_classify,
+    is_test=_is_test,
+    module_name=module_name,
+    import_map=_import_map,
+    dependency_module_suffixes=(".java",),
+    dependency_package_directories=True,
+    switch_types=frozenset({"switch_expression"}),
+    switch_value_field="condition",
+    switch_cases=_switch_cases,
+    loop_types=frozenset(
+        {"for_statement", "enhanced_for_statement", "while_statement", "do_statement"}
+    ),
+    throw_types=frozenset({"throw_statement"}),
+    call_types=frozenset({"method_invocation", "object_creation_expression"}),
+    call_name=_call_name,
+    try_type="try_statement",
+    catch_types=frozenset({"catch_clause"}),
+    finally_types=frozenset({"finally_clause"}),
+    assignment_types=frozenset({"local_variable_declaration", "assignment_expression"}),
+    nested_def_types=frozenset({"lambda_expression"}),
+)
+
+
+def build_analyzer(root: Path, config: CodeDebriefConfig) -> TreeSitterAnalyzer:
+    return TreeSitterAnalyzer(root, config, JAVA_PROFILE)

codedebrief/analysis/languages/php.py

@@ -0,0 +1,83 @@
+"""PHP language profile for the profile-driven tree-sitter analyzer."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import tree_sitter_php
+
+from codedebrief.analysis.languages._common import container_definitions, module_name, text
+from codedebrief.analysis.treesitter import (
+    LanguageProfile,
+    TreeSitterAnalyzer,
+    TSDefinition,
+)
+from codedebrief.config import CodeDebriefConfig
+
+_CONTAINERS = frozenset(
+    {"class_declaration", "interface_declaration", "trait_declaration", "enum_declaration"}
+)
+_METHODS = frozenset({"method_declaration", "function_definition"})
+_VISIBILITY = {"visibility_modifier", "static_modifier", "abstract_modifier"}
+
+
+def _classify(
+    definition: TSDefinition, relative: str, source: str, config: CodeDebriefConfig
+) -> tuple[str, str, bool]:
+    override = config.entrypoint_override(f"{relative}:{definition.owner}.{definition.name}")
+    visibility = " ".join(
+        text(c, source.encode("utf-8")) for c in definition.node.children if c.type in _VISIBILITY
+    )
+    is_private = "private" in visibility or "protected" in visibility
+    entry_kind = "method" if definition.owner else "function"
+    public = config.include_public_functions and not is_private
+    return "generic", entry_kind, override if override is not None else public
+
+
+def _is_test(relative: str, name: str) -> bool:
+    # PHPUnit convention: a *Test.php class under a `test`/`tests` segment. Drop the old
+    # `*test.php` substring match (it caught legitimate files like `latest.php` /
+    # `request.php`) and the bare `test`-prefixed method name (a real method otherwise).
+    segments = relative.split("/")
+    return any(segment.lower() in {"test", "tests"} for segment in segments[:-1]) or segments[
+        -1
+    ].endswith("Test.php")
+
+
+def _call_name(call: Any, source: bytes) -> str:
+    if call.type == "function_call_expression":
+        return text(call.child_by_field_name("function"), source)
+    return text(call.child_by_field_name("name"), source)
+
+
+PHP_PROFILE = LanguageProfile(
+    language="php",
+    grammar_loader=tree_sitter_php.language_php,
+    function_types=_METHODS,
+    definitions=container_definitions(_CONTAINERS, _METHODS),
+    classify=_classify,
+    is_test=_is_test,
+    module_name=module_name,
+    block_types=frozenset({"compound_statement"}),
+    consequence_field="body",
+    switch_types=frozenset({"switch_statement"}),
+    switch_value_field="condition",
+    case_types=frozenset({"case_statement"}),
+    default_types=frozenset({"default_statement"}),
+    case_fall_through=True,
+    loop_types=frozenset({"for_statement", "while_statement", "foreach_statement", "do_statement"}),
+    call_types=frozenset(
+        {"function_call_expression", "member_call_expression", "scoped_call_expression"}
+    ),
+    call_name=_call_name,
+    try_type="try_statement",
+    catch_types=frozenset({"catch_clause"}),
+    finally_types=frozenset({"finally_clause"}),
+    assignment_types=frozenset({"assignment_expression"}),
+    nested_def_types=frozenset({"anonymous_function_creation_expression", "arrow_function"}),
+)
+
+
+def build_analyzer(root: Path, config: CodeDebriefConfig) -> TreeSitterAnalyzer:
+    return TreeSitterAnalyzer(root, config, PHP_PROFILE)

codedebrief/analysis/languages/ruby.py

@@ -0,0 +1,75 @@
+"""Ruby language profile for the profile-driven tree-sitter analyzer."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import tree_sitter_ruby
+
+from codedebrief.analysis.languages._common import container_definitions, module_name, text
+from codedebrief.analysis.treesitter import (
+    LanguageProfile,
+    TreeSitterAnalyzer,
+    TSDefinition,
+)
+from codedebrief.config import CodeDebriefConfig
+
+_CONTAINERS = frozenset({"class", "module", "singleton_class"})
+_METHODS = frozenset({"method", "singleton_method"})
+
+
+def _classify(
+    definition: TSDefinition, relative: str, source: str, config: CodeDebriefConfig
+) -> tuple[str, str, bool]:
+    owner_prefix = f"{definition.owner}." if definition.owner else ""
+    override = config.entrypoint_override(f"{relative}:{owner_prefix}{definition.name}")
+    entry_kind = "method" if definition.owner else "function"
+    public = config.include_public_functions and not definition.name.startswith("_")
+    return "generic", entry_kind, override if override is not None else public
+
+
+def _is_test(relative: str, name: str) -> bool:
+    # RSpec/minitest convention: a `spec`/`test` directory segment or a *_spec.rb /
+    # *_test.rb file. Anchor to path SEGMENTS so `contest/` won't match, and drop the
+    # bare `test`-prefixed method name (`test_helper` is a real method in `lib/`).
+    segments = relative.lower().split("/")
+    return any(segment in {"spec", "test"} for segment in segments[:-1]) or segments[-1].endswith(
+        ("_spec.rb", "_test.rb")
+    )
+
+
+def _call_name(call: Any, source: bytes) -> str:
+    method = call.child_by_field_name("method")
+    if method is not None:
+        return text(method, source)
+    ident = next((c for c in call.children if c.type in {"identifier", "constant"}), None)
+    return text(ident, source)
+
+
+RUBY_PROFILE = LanguageProfile(
+    language="ruby",
+    grammar_loader=tree_sitter_ruby.language,
+    function_types=_METHODS,
+    definitions=container_definitions(_CONTAINERS, _METHODS),
+    classify=_classify,
+    is_test=_is_test,
+    module_name=module_name,
+    block_types=frozenset({"body_statement", "then", "else", "do_block", "begin"}),
+    if_type="if",
+    alternative_types=frozenset({"else"}),
+    switch_types=frozenset({"case"}),
+    switch_value_field="value",
+    switch_body_field=None,
+    case_types=frozenset({"when"}),
+    case_value_field="pattern",
+    default_types=frozenset({"else"}),
+    return_type="return",
+    loop_types=frozenset({"while", "until", "for"}),
+    call_types=frozenset({"call", "command_call", "method_call"}),
+    call_name=_call_name,
+)
+
+
+def build_analyzer(root: Path, config: CodeDebriefConfig) -> TreeSitterAnalyzer:
+    return TreeSitterAnalyzer(root, config, RUBY_PROFILE)

codedebrief/analysis/languages/rust.py

@@ -0,0 +1,96 @@
+"""Rust language profile for the profile-driven tree-sitter analyzer."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+import tree_sitter_rust
+
+from codedebrief.analysis.languages._common import module_name, named, text
+from codedebrief.analysis.treesitter import (
+    LanguageProfile,
+    TreeSitterAnalyzer,
+    TSDefinition,
+)
+from codedebrief.config import CodeDebriefConfig
+
+
+def _definitions(
+    root: Any, source: bytes, relative: str, profile: LanguageProfile
+) -> Iterable[TSDefinition]:
+    yield from _walk(root, source, owner="")
+
+
+def _walk(node: Any, source: bytes, owner: str) -> Iterable[TSDefinition]:
+    if node.type == "impl_item":
+        name = text(node.child_by_field_name("type"), source)
+        for child in named(node.child_by_field_name("body")):
+            yield from _walk(child, source, name)
+        return
+    if node.type in {"mod_item", "trait_item"}:
+        body = node.child_by_field_name("body")
+        for child in named(body if body is not None else node):
+            yield from _walk(child, source, owner)
+        return
+    if node.type == "function_item":
+        name = text(node.child_by_field_name("name"), source)
+        body = node.child_by_field_name("body")
+        if name and body is not None:
+            yield TSDefinition(name=name, node=node, body=body, owner=owner)
+        return
+    for child in named(node):
+        yield from _walk(child, source, owner)
+
+
+def _classify(
+    definition: TSDefinition, relative: str, source: str, config: CodeDebriefConfig
+) -> tuple[str, str, bool]:
+    owner_prefix = f"{definition.owner}." if definition.owner else ""
+    override = config.entrypoint_override(f"{relative}:{owner_prefix}{definition.name}")
+    if definition.name == "main" and not definition.owner:
+        return "rust", "main", override if override is not None else True
+    is_pub = any(c.type == "visibility_modifier" for c in definition.node.children)
+    entry_kind = "method" if definition.owner else "function"
+    public = config.include_public_functions and is_pub
+    return "generic", entry_kind, override if override is not None else public
+
+
+def _is_test(relative: str, name: str) -> bool:
+    # A Rust test is a `#[test]`/`#[cfg(test)]` item or a file under the `tests/`
+    # integration directory - never a bare `test`-prefixed name (a real `test_render`
+    # helper in `src/` must stay an analyzable function). The `(relative, name)` signature
+    # can't see attributes, so anchor to the `tests/` path SEGMENT (the convention this
+    # profile can detect); attribute-gated `#[test]` items are handled where they parse.
+    segments = relative.lower().split("/")
+    return "tests" in segments[:-1] or segments[-1] == "tests.rs"
+
+
+RUST_PROFILE = LanguageProfile(
+    language="rust",
+    grammar_loader=tree_sitter_rust.language,
+    function_types=frozenset({"function_item"}),
+    definitions=_definitions,
+    classify=_classify,
+    is_test=_is_test,
+    module_name=module_name,
+    if_type="if_expression",
+    return_type="return_expression",
+    switch_types=frozenset({"match_expression"}),
+    switch_value_field="value",
+    switch_body_field="body",
+    case_types=frozenset({"match_arm"}),
+    case_value_field="pattern",
+    wildcard_values=frozenset({"_"}),
+    exhaustive_switch=True,
+    loop_types=frozenset({"loop_expression", "while_expression", "for_expression"}),
+    call_types=frozenset({"call_expression"}),
+    assignment_types=frozenset({"let_declaration"}),
+    nested_def_types=frozenset({"closure_expression"}),
+    unwrap_types=frozenset({"expression_statement"}),
+)
+
+
+def build_analyzer(root: Path, config: CodeDebriefConfig) -> TreeSitterAnalyzer:
+    return TreeSitterAnalyzer(root, config, RUST_PROFILE)