codegraph-py 1.0.0__py3-none-any.whl

codegraph/extraction/languages/lua_cfg.py

@@ -0,0 +1,65 @@
+"""
+Lua language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class LuaConfig(LanguageConfig):
+    """Lua extraction configuration."""
+
+    language_id = 'lua'
+
+    function_types = ['function_declaration']
+    class_types = []
+    method_types = ['function_declaration']  # Methods using self syntax
+    interface_types = []
+    struct_types = []
+    enum_types = []
+    type_alias_types = []
+    import_types = ['require_statement']
+    call_types = ['function_call']
+    variable_types = ['variable_declaration', 'assignment_statement']
+    field_types = ['field']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = None
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        return source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'require_statement':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            # require('module') or require "module"
+            arg = node.child_by_field_name('module') or node.child(1)
+            if arg:
+                module_name = source[arg.start_byte:arg.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('\'"')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        # Lua: functions in module scope, not starting with _
+        name_node = node.child_by_field_name('name')
+        if name_node:
+            try:
+                t = name_node.text
+                if isinstance(t, bytes):
+                    name = t.decode('utf-8', errors='replace')
+                else:
+                    name = str(t)
+                return not name.startswith('_')
+            except Exception:
+                pass
+        return True
+
+    def classify_class_node(self, node: TSNode) -> str:
+        # Lua uses metatables, treat function_declaration returning a table as class
+        return 'class'

codegraph/extraction/languages/python_cfg.py

@@ -0,0 +1,75 @@
+"""
+Python language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class PythonConfig(LanguageConfig):
+    """Python-specific extraction configuration."""
+
+    language_id = 'python'
+
+    function_types = ['function_definition']
+    class_types = ['class_definition']
+    method_types = ['function_definition']  # Methods are functions inside classes
+    interface_types = []
+    struct_types = []
+    enum_types = []
+    type_alias_types = []
+    import_types = ['import_statement', 'import_from_statement']
+    call_types = ['call']
+    variable_types = ['assignment']
+    field_types = []
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'return_type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        return_type = node.child_by_field_name('return_type')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        if return_type:
+            sig += ' -> ' + source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+        return sig
+
+    def is_async(self, node: TSNode) -> bool:
+        prev = node.prev_sibling
+        return prev is not None and prev.type == 'async'
+
+    def is_static(self, node: TSNode) -> bool:
+        prev = node.prev_named_sibling
+        if prev is not None and prev.type == 'decorator':
+            text = _node_text(prev)
+            return 'staticmethod' in text
+        return False
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+        if node.type == 'import_from_statement':
+            module_node = node.child_by_field_name('module_name')
+            if module_node:
+                module_name = source[module_node.start_byte:module_node.end_byte].decode('utf-8', errors='replace')
+                return ImportInfo(module_name=module_name, signature=text)
+        elif node.type == 'import_statement':
+            name_node = node.child_by_field_name('name')
+            if name_node:
+                module_name = source[name_node.start_byte:name_node.end_byte].decode('utf-8', errors='replace')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+
+def _node_text(node: TSNode) -> str:
+    """Get text from a tree-sitter node safely."""
+    try:
+        t = node.text
+        if isinstance(t, bytes):
+            return t.decode('utf-8', errors='replace')
+        return str(t)
+    except Exception:
+        return ''

codegraph/extraction/languages/ruby_cfg.py

@@ -0,0 +1,48 @@
+"""
+Ruby language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class RubyConfig(LanguageConfig):
+    """Ruby extraction configuration."""
+
+    language_id = 'ruby'
+
+    function_types = ['method']
+    class_types = ['class']
+    method_types = ['method']  # Methods inside class bodies
+    interface_types = []
+    struct_types = []
+    enum_types = []
+    type_alias_types = []
+    import_types = ['require', 'require_relative']
+    call_types = ['call', 'method_call']
+    variable_types = ['assignment']
+    field_types = []
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = None
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        return source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+        if node.type in ('require', 'require_relative'):
+            arg = node.child_by_field_name('path') or node.child(1)
+            if arg:
+                module_name = source[arg.start_byte:arg.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('\'"')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        return not node.type.startswith('_')

codegraph/extraction/languages/rust_cfg.py

@@ -0,0 +1,68 @@
+"""
+Rust language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class RustConfig(LanguageConfig):
+    """Rust extraction configuration."""
+
+    language_id = 'rust'
+
+    function_types = ['function_item']
+    class_types = []
+    method_types = ['function_item']  # Methods in impl blocks
+    interface_types = []
+    struct_types = ['struct_item']
+    enum_types = ['enum_item']
+    type_alias_types = ['type_item']
+    import_types = ['use_declaration']
+    call_types = ['call_expression']
+    variable_types = ['let_declaration']
+    field_types = []
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'return_type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('return_type')
+        if return_type:
+            sig += ' -> ' + source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'use_declaration':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            # Extract the first path segment
+            arg = node.child_by_field_name('argument')
+            if arg:
+                module_name = source[arg.start_byte:arg.end_byte].decode('utf-8', errors='replace')
+                # Get the top-level crate/module name
+                top_level = module_name.split('::')[0]
+                return ImportInfo(module_name=top_level, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        # Check for 'pub' keyword
+        prev = node.prev_sibling
+        while prev is not None:
+            if prev.type == 'pub':
+                return True
+            if prev.is_named and prev.type != 'pub':
+                break
+            prev = prev.prev_sibling
+        return False
+
+    def classify_class_node(self, node: TSNode) -> str:
+        # Rust uses `impl` blocks for implementations
+        if node.type == 'impl_item':
+            return 'class'  # Treat impl blocks as containers for methods
+        return 'class'

codegraph/extraction/languages/scala_cfg.py

@@ -0,0 +1,59 @@
+"""
+Scala language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class ScalaConfig(LanguageConfig):
+    """Scala extraction configuration."""
+
+    language_id = 'scala'
+
+    function_types = ['function_definition']
+    class_types = ['class_definition']
+    method_types = ['function_definition']  # Functions inside class/object bodies
+    interface_types = ['trait_definition']
+    struct_types = []
+    enum_types = ['enum_definition']
+    type_alias_types = ['type_definition']
+    import_types = ['import_statement']
+    call_types = ['call_expression']
+    variable_types = ['val_definition', 'var_definition']
+    field_types = ['variable_definition']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'return_type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('return_type')
+        if return_type:
+            ret = source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+            sig += f': {ret}'
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'import_statement':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            path = node.child_by_field_name('path')
+            if path:
+                module_name = source[path.start_byte:path.end_byte].decode('utf-8', errors='replace')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        return True  # Scala defs at package level are public by default
+
+    def is_static(self, node: TSNode) -> bool:
+        # Check for 'static' modifier in Scala 3
+        for child in node.children:
+            if child.type == 'static':
+                return True
+        return False

codegraph/extraction/languages/swift_cfg.py

@@ -0,0 +1,64 @@
+"""
+Swift language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+class SwiftConfig(LanguageConfig):
+    """Swift extraction configuration."""
+
+    language_id = 'swift'
+
+    function_types = ['function_declaration']
+    class_types = ['class_declaration']
+    method_types = ['function_declaration']  # Functions inside class bodies
+    interface_types = ['protocol_declaration']
+    struct_types = ['struct_declaration']
+    enum_types = ['enum_declaration']
+    type_alias_types = ['typealias_declaration']
+    import_types = ['import_declaration']
+    call_types = ['call_expression']
+    variable_types = ['variable_declaration']
+    field_types = ['property_declaration']
+    property_types = []
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'return_type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('return_type')
+        if return_type:
+            sig += ' -> ' + source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        if node.type == 'import_declaration':
+            text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+            # Get the module path (all children after 'import' keyword)
+            parts = []
+            for child in node.named_children:
+                t = source[child.start_byte:child.end_byte].decode('utf-8', errors='replace')
+                parts.append(t)
+            module_name = '.'.join(parts) if parts else ''
+            return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        # Check for 'public' or 'open' modifiers
+        for child in node.children:
+            if child.type in ('public', 'open'):
+                return True
+        return False
+
+    def is_static(self, node: TSNode) -> bool:
+        for child in node.children:
+            if child.type == 'static':
+                return True
+        return False

codegraph/extraction/languages/typescript_cfg.py

@@ -0,0 +1,89 @@
+"""
+TypeScript/TSX language extraction configuration.
+"""
+from tree_sitter import Node as TSNode
+from .base import LanguageConfig, ImportInfo
+
+
+def _node_text(node: TSNode) -> str:
+    try:
+        t = node.text
+        if isinstance(t, bytes):
+            return t.decode('utf-8', errors='replace')
+        return str(t)
+    except Exception:
+        return ''
+
+
+class TypeScriptConfig(LanguageConfig):
+    """TypeScript/TSX extraction configuration."""
+
+    language_id = 'typescript'
+
+    # TS uses 'typescript' grammar, access specific dialects via 'typescript' or 'tsx'
+    _tsx = False
+
+    function_types = ['function_declaration', 'arrow_function', 'generator_function_declaration']
+    class_types = ['class_declaration']
+    method_types = ['method_definition']
+    interface_types = ['interface_declaration']
+    struct_types = []
+    enum_types = ['enum_declaration']
+    type_alias_types = ['type_alias_declaration']
+    import_types = ['import_statement']
+    call_types = ['call_expression']
+    variable_types = ['variable_declaration', 'lexical_declaration']
+    field_types = ['property_signature', 'public_field_definition']
+    property_types = ['property_identifier']
+
+    name_field = 'name'
+    body_field = 'body'
+    params_field = 'parameters'
+    return_field = 'type'
+
+    def get_signature(self, node: TSNode, source: bytes) -> str | None:
+        params = node.child_by_field_name('parameters')
+        if not params:
+            return None
+        sig = source[params.start_byte:params.end_byte].decode('utf-8', errors='replace')
+        return_type = node.child_by_field_name('return_type')
+        if return_type:
+            sig += ': ' + source[return_type.start_byte:return_type.end_byte].decode('utf-8', errors='replace')
+        return sig
+
+    def extract_import(self, node: TSNode, source: bytes) -> ImportInfo | None:
+        text = source[node.start_byte:node.end_byte].decode('utf-8', errors='replace').strip()
+        if node.type == 'import_statement':
+            source_node = node.child_by_field_name('source')
+            if source_node:
+                module_name = source[source_node.start_byte:source_node.end_byte].decode('utf-8', errors='replace')
+                module_name = module_name.strip('\'"')
+                return ImportInfo(module_name=module_name, signature=text)
+        return None
+
+    def is_exported(self, node: TSNode, source: bytes) -> bool:
+        prev = node.prev_sibling
+        while prev is not None:
+            if prev.type == 'export':
+                return True
+            if prev.is_named or prev.type in (';', '\n'):
+                break
+            prev = prev.prev_sibling
+        return False
+
+    def is_async(self, node: TSNode) -> bool:
+        prev = node.prev_sibling
+        while prev is not None:
+            if prev.type == 'async':
+                return True
+            if prev.is_named:
+                break
+            prev = prev.prev_sibling
+        return False
+
+    def is_const(self, node: TSNode) -> bool:
+        parent = node.parent
+        if parent and parent.type == 'variable_declaration':
+            kind = _node_text(parent.child(0)) if parent.child(0) else ''
+            return kind == 'const'
+        return False