Prepare 1.3.0 release

Author: xnuinside

CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-01-24
+
+### Added
+
+- Pluggable parser architecture with registry and base parser interface
+- Rust parser stub to establish language extension points
+- AST-based Python parser with cross-version parsing support (Python 2.x via typed-ast)
+- CLI options for language selection and target Python version
+- Expanded test coverage for parsers, registry/utils, visualizer helpers, and legacy parser objects
+- SUGGESTIONS.md with project improvement ideas
+
+### Changed
+
+- Core now delegates parsing and dependency analysis to language parsers
+- Python dependency detection now uses AST rather than token scanning
+- Utilities now support multi-extension file discovery
+
+### Fixed
+
+- Legacy parser now handles comma-separated imports in a single statement
+- Removed known false positives from string literals and alias leakage (AST parser)
+
 ## [1.2.0] - 2026-01-18
 
 ### Added

codegraph/__init__.py

@@ -1 +1 @@
-__version__ = "1.2.0"
+__version__ = "1.3.0"

codegraph/parser.py

@@ -121,7 +121,8 @@ def create_objects_array(fname, source):  # noqa: C901
                 new_lines += 1
 
             elif token == "import":
-                modules = [_line.replace("\n", "").split("import ")[1]]
+                modules_part = _line.replace("\n", "").split("import ", 1)[1]
+                modules = [part.strip() for part in modules_part.split(",") if part.strip()]
                 if not imports:
                     imports = Import(modules)
                 else:

codegraph/parsers/python_parser.py

@@ -35,6 +35,9 @@ def __init__(self, args=None, python_version: Optional[str] = None) -> None:
         if python_version is None and args is not None:
             python_version = getattr(args, "python_version", None)
         self._python_version = python_version
+        self._major, self._minor = self._parse_python_version(self._python_version)
+        self._ast_mod = ast27 if self._major == 2 else ast
+        self._feature_version = self._minor if self._major == 3 else None
         self._module_names_set: Set[str] = set()
 
     def get_source_files(self, paths) -> List[str]:
@@ -116,16 +119,14 @@ def _read_file_content(self, path: Text) -> Text:
             return file_read.read()
 
     def _parse_source(self, source: Text, filename: Text):
-        major, minor = self._parse_python_version(self._python_version)
-        if major == 2:
+        if self._major == 2:
             if ast27 is None:
                 raise ImportError(
                     "typed_ast is required to parse Python 2 source code."
                 )
             return ast27.parse(source, filename=filename, mode="exec")
 
-        feature_version = minor if minor is not None else None
-        return self._parse_with_feature_version(source, filename, feature_version)
+        return self._parse_with_feature_version(source, filename, self._feature_version)
 
     def _parse_with_feature_version(self, source: Text, filename: Text, feature_version: Optional[int]):
         if feature_version is None:
@@ -159,26 +160,25 @@ def _parse_python_version(self, version: Optional[str]) -> Tuple[int, Optional[i
     def _extract_entities(self, ast_tree, filename: Text) -> (List[object], Dict[str, object]):
         entities: List[object] = []
         entity_nodes: Dict[str, object] = {}
-        ast_mod = ast27 if self._python_version and self._python_version.startswith("2") else ast
-
-        async_def = getattr(ast_mod, "AsyncFunctionDef", None)
+        ast_mod = self._ast_mod
+        async_def = getattr(self._ast_mod, "AsyncFunctionDef", None)
 
         for node in getattr(ast_tree, "body", []):
-            if isinstance(node, ast_mod.FunctionDef):
+            if isinstance(node, self._ast_mod.FunctionDef):
                 func = Function(node.name, filename, node.lineno)
-                func.endno = self._get_end_lineno(node, ast_mod)
+                func.endno = self._get_end_lineno(node, self._ast_mod)
                 entities.append(func)
                 entity_nodes[node.name] = node
             elif async_def and isinstance(node, async_def):
                 func = AsyncFunction(node.name, filename, node.lineno)
-                func.endno = self._get_end_lineno(node, ast_mod)
+                func.endno = self._get_end_lineno(node, self._ast_mod)
                 entities.append(func)
                 entity_nodes[node.name] = node
-            elif isinstance(node, ast_mod.ClassDef):
+            elif isinstance(node, self._ast_mod.ClassDef):
                 bases = [self._get_name_from_expr(base, ast_mod) for base in node.bases]
                 bases = [b for b in bases if b]
                 cls = Class(node.name, bases, filename, node.lineno)
-                cls.endno = self._get_end_lineno(node, ast_mod)
+                cls.endno = self._get_end_lineno(node, self._ast_mod)
                 entities.append(cls)
                 entity_nodes[node.name] = node
 
@@ -188,7 +188,7 @@ def _collect_imports(self, ast_tree) -> ImportInfo:
         module_aliases: Dict[str, str] = {}
         entity_aliases: Dict[str, str] = {}
         module_imports: Set[str] = set()
-        ast_mod = ast27 if self._python_version and self._python_version.startswith("2") else ast
+        ast_mod = self._ast_mod
 
         for node in getattr(ast_tree, "body", []):
             if isinstance(node, ast_mod.Import):
@@ -207,10 +207,8 @@ def _collect_imports(self, ast_tree) -> ImportInfo:
                     full_name = f"{base}.{name}" if base else name
                     resolved = self._resolve_imported_module(full_name)
                     if resolved:
-                        module_aliases[alias_name] = resolved
                         module_imports.add(resolved)
-                    else:
-                        entity_aliases[alias_name] = full_name
+                    entity_aliases[alias_name] = full_name
 
         return ImportInfo(
             module_aliases=module_aliases,
@@ -234,14 +232,14 @@ def _collect_dependencies_in_module(
         entity_aliases: Dict[str, str],
     ) -> List[str]:
         deps: List[str] = []
-        ast_mod = ast27 if self._python_version and self._python_version.startswith("2") else ast
+        ast_mod = self._ast_mod
         collector = self._make_dependency_collector(
             local_entities, module_aliases, entity_aliases, ast_mod
         )
         for node in getattr(ast_tree, "body", []):
             if isinstance(node, (ast_mod.FunctionDef, ast_mod.ClassDef)):
                 continue
-            async_def = getattr(ast_mod, "AsyncFunctionDef", None)
+            async_def = getattr(self._ast_mod, "AsyncFunctionDef", None)
             if async_def and isinstance(node, async_def):
                 continue
             collector.visit(node)
@@ -256,7 +254,7 @@ def _collect_dependencies_in_entity(
         entity_aliases: Dict[str, str],
     ) -> List[str]:
         deps: List[str] = []
-        ast_mod = ast27 if self._python_version and self._python_version.startswith("2") else ast
+        ast_mod = self._ast_mod
 
         if isinstance(node, ast_mod.ClassDef):
             for base in node.bases:
@@ -339,7 +337,9 @@ def _resolve_attribute(
             suffix = ".".join(parts[1:])
             return f"{module_name}.{suffix}" if suffix else module_name
         if base in entity_aliases:
-            return entity_aliases[base]
+            base_name = entity_aliases[base]
+            suffix = ".".join(parts[1:])
+            return f"{base_name}.{suffix}" if suffix else base_name
         if base in local_entities:
             return base
         return None
@@ -369,6 +369,14 @@ def _flatten_attribute(self, node, ast_mod) -> List[str]:
             return parts
         return []
 
+    def _get_name_from_expr(self, node, ast_mod) -> Optional[str]:
+        if isinstance(node, ast_mod.Name):
+            return node.id
+        if isinstance(node, ast_mod.Attribute):
+            parts = self._flatten_attribute(node, ast_mod)
+            return ".".join(parts) if parts else None
+        return None
+
     def _get_end_lineno(self, node, ast_mod) -> int:
         end_lineno = getattr(node, "end_lineno", None)
         if end_lineno:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codegraph"
-version = "1.2.0"
+version = "1.3.0"
 license = "MIT"
 readme = "docs/README.rst"
 homepage = "https://github.com/xnuinside/codegraph"

tests/test_known_limitations.py

@@ -1,12 +1,9 @@
 from argparse import Namespace
 
-import pytest
-
 from codegraph.core import CodeGraph
 from codegraph.parser import Import, create_objects_array
 
 
-@pytest.mark.xfail(reason="Token-based parser does not split comma-separated imports.")
 def test_import_comma_separated_statement():
     source = """import os, sys
 
@@ -20,7 +17,6 @@ def func():
     assert "sys" in imports.modules
 
 
-@pytest.mark.xfail(reason="String literals are scanned for usage, causing false positives.")
 def test_usage_in_string_literal_is_not_dependency(tmp_path):
     module_path = tmp_path / "module_a.py"
     module_path.write_text(
@@ -40,7 +36,6 @@ def bar():
     assert "foo" not in usage_graph[module_path.as_posix()]["bar"]
 
 
-@pytest.mark.xfail(reason="Global alias map leaks across modules, causing false positives.")
 def test_alias_leak_between_modules(tmp_path):
     module_b = tmp_path / "module_b.py"
     module_b.write_text(

tests/test_legacy_parser_objects.py

@@ -0,0 +1,32 @@
+from codegraph import parser as legacy
+
+
+def test_object_children_and_repr():
+    parent = legacy._Object("parent", "file.py", 1, None)
+    child = legacy.Function("child", "file.py", 2)
+    parent._addchild("child", child)
+
+    assert parent.children["child"] is child
+    assert child.main is parent
+    assert "parent" in repr(parent)
+    assert "parent" in str(parent)
+
+
+def test_class_methods_and_nesting():
+    cls = legacy.Class("MyClass", [], "file.py", 1)
+    method = legacy._nest_function(cls, "method", 2)
+    async_method = legacy._nest_function(cls, "amethod", 3, async_f=True)
+    nested_class = legacy._nest_class(cls, "Nested", 4)
+
+    assert "method" in cls.methods
+    assert "amethod" in cls.async_methods
+    assert cls.children["Nested"] is nested_class
+    assert method in cls.methods.values()
+    assert async_method in cls.async_methods.values()
+
+
+def test_import_add():
+    imp = legacy.Import(["os"])
+    imp.add("sys")
+    assert "os" in imp.modules
+    assert "sys" in imp.modules

tests/test_parsers_and_utils.py

@@ -0,0 +1,59 @@
+from argparse import Namespace
+
+import pytest
+
+from codegraph.parsers import available_languages, get_parser
+from codegraph.parsers.base import BaseParser
+from codegraph.utils import get_paths_list
+
+
+class DummyParser(BaseParser):
+    language = "dummy"
+
+    def get_source_files(self, paths):
+        return []
+
+    def parse_files(self, paths_list):
+        return {}
+
+    def usage_graph(self, modules_data):
+        return {}
+
+    def get_entity_metadata(self, modules_data):
+        return {}
+
+
+def test_available_languages_contains_python_and_rust():
+    langs = available_languages()
+    assert "python" in langs
+    assert "rust" in langs
+
+
+def test_get_parser_returns_python_parser():
+    parser = get_parser("python", args=Namespace())
+    assert parser.language == "python"
+
+
+def test_get_parser_unsupported_language():
+    with pytest.raises(ValueError):
+        get_parser("nope")
+
+
+def test_base_parser_get_dependencies():
+    parser = DummyParser()
+    usage_graph = {
+        "a.py": {"func": ["b.func", "c.other"], "_": []},
+        "b.py": {"func": []},
+    }
+
+    deps = parser.get_dependencies(usage_graph, "a.py", 1)
+    assert deps[1] == {"b.py", "c.py"}
+
+
+def test_get_paths_list_multi_extension(tmp_path):
+    (tmp_path / "a.py").write_text("", encoding="utf-8")
+    (tmp_path / "b.txt").write_text("", encoding="utf-8")
+
+    paths = get_paths_list(tmp_path.as_posix(), [".py", ".txt"])
+    names = {p.split("/")[-1] for p in paths}
+    assert names == {"a.py", "b.txt"}