feat: Java/Kotlin import edges via longest package-prefix resolution (issue-2, PR 2/3) (#31)

Author: NehharShah

src/repokg/deps.py

@@ -37,6 +37,9 @@
 JVM_BUILD_FILES = ("pom.xml", "build.gradle", "build.gradle.kts")
 # `package a.b.c;` (Java) / `package a.b.c` (Kotlin, no semicolon).
 JVM_PACKAGE_RE = re.compile(r"^\s*package\s+([A-Za-z_][\w.]*)\s*;?\s*$", re.M)
+# `import a.b.C;` / `import static a.b.C.m;` / `import a.b.*;` (captured with a
+# trailing dot, stripped in code) / Kotlin `import a.b.C as D`.
+JVM_IMPORT_RE = re.compile(r"^\s*import\s+(?:static\s+)?([A-Za-z_][\w.]*)", re.M)
 JVM_EXTS = (".java", ".kt")
 
 
@@ -54,6 +57,7 @@ def collect(repo, tree=None):
     _py_edges(repo, tree, dirs, counter)
     _js_edges(repo, tree, dirs, counter)
     _rust_edges(repo, tree, counter)
+    _jvm_edges(repo, tree, counter)
 
     edges = [{"from": f or "(root)", "to": t or "(root)", "lang": lang, "count": n}
              for (f, t, lang), n in counter.items()]
@@ -263,6 +267,49 @@ def _jvm_modules(tree):
                   if any(b in files for b in JVM_BUILD_FILES))
 
 
+def _jvm_edges(repo, tree, counter):
+    """Java/Kotlin edges: imports resolved against the package-declaration
+    index by longest package prefix. Externals (java.*, kotlin.*, third-party)
+    are never in the index, so they drop out naturally."""
+    index = _jvm_package_index(repo, tree)
+    if not index:
+        return
+    for rel, files in tree.items():
+        for f in files:
+            if not f.endswith(JVM_EXTS):
+                continue
+            lang = "Kotlin" if f.endswith(".kt") else "Java"
+            for path in JVM_IMPORT_RE.findall(_read(repo, rel, f)):
+                dirs = _jvm_resolve(path.rstrip("."), index)
+                for target in _jvm_prefer_main(dirs):
+                    if target != rel:
+                        counter[(rel, target, lang)] += 1
+
+
+def _jvm_resolve(path, index):
+    """Longest package prefix of an import path present in the index.
+
+    Full path first (wildcard imports name the package itself), then
+    successively dropping trailing segments (class name, nested classes)."""
+    parts = path.split(".")
+    for i in range(len(parts), 0, -1):
+        dirs = index.get(".".join(parts[:i]))
+        if dirs:
+            return dirs
+    return ()
+
+
+def _jvm_prefer_main(dirs):
+    """A package usually exists in both main and test source roots; edges
+    into test dirs from an import would be fabricated, so prefer non-test
+    dirs when the package is declared in several places."""
+    if len(dirs) <= 1:
+        return sorted(dirs)
+    main = [d for d in dirs
+            if not {"test", "tests"} & set(d.split("/"))]
+    return sorted(main) or sorted(dirs)
+
+
 def _jvm_package_index(repo, tree):
     """{package name -> set of dirs declaring it}, from `package` declarations.
 

tests/test_deps_jvm.py

@@ -61,3 +61,64 @@ def test_default_package_files_ignored(self):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestJVMEdges(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.repo = self.tmp.name
+        write(self.repo, "core/src/main/java/com/acme/core/Engine.java",
+              "package com.acme.core;\npublic class Engine { public static void run() {} }\n")
+        write(self.repo, "core/src/main/java/com/acme/core/util/Str.java",
+              "package com.acme.core.util;\npublic class Str {}\n")
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def edges(self):
+        from repokg.deps import collect
+        return {(e["from"], e["to"], e["lang"]): e["count"]
+                for e in collect(self.repo) if e["lang"] in ("Java", "Kotlin")}
+
+    def test_java_import_static_wildcard_and_externals(self):
+        write(self.repo, "api/src/main/java/com/acme/api/Handler.java",
+              "package com.acme.api;\n"
+              "import java.util.List;\n"                      # external -> dropped
+              "import com.acme.core.Engine;\n"                # class import
+              "import static com.acme.core.Engine.run;\n"     # static member
+              "import com.acme.core.util.*;\n"                # wildcard = package itself
+              "public class Handler {}\n")
+        self.assertEqual(self.edges(), {
+            ("api/src/main/java/com/acme/api",
+             "core/src/main/java/com/acme/core", "Java"): 2,
+            ("api/src/main/java/com/acme/api",
+             "core/src/main/java/com/acme/core/util", "Java"): 1,
+        })
+
+    def test_kotlin_import_with_alias(self):
+        write(self.repo, "api/src/main/kotlin/Handlers.kt",
+              "package com.acme.api\n"
+              "import com.acme.core.Engine as E\n"
+              "import kotlin.collections.listOf\n"
+              "fun handle() = E.run()\n")
+        self.assertEqual(self.edges(), {
+            ("api/src/main/kotlin",
+             "core/src/main/java/com/acme/core", "Kotlin"): 1,
+        })
+
+    def test_test_source_root_not_targeted_when_main_exists(self):
+        # same package declared in a test root must not attract edges
+        write(self.repo, "core/src/test/java/com/acme/core/EngineTest.java",
+              "package com.acme.core;\nclass EngineTest {}\n")
+        write(self.repo, "api/src/main/java/com/acme/api/H.java",
+              "package com.acme.api;\nimport com.acme.core.Engine;\nclass H {}\n")
+        edges = self.edges()
+        self.assertIn(("api/src/main/java/com/acme/api",
+                       "core/src/main/java/com/acme/core", "Java"), edges)
+        self.assertNotIn(("api/src/main/java/com/acme/api",
+                          "core/src/test/java/com/acme/core", "Java"), edges)
+
+    def test_same_package_import_no_self_edge(self):
+        write(self.repo, "core/src/main/java/com/acme/core/Other.java",
+              "package com.acme.core;\nimport com.acme.core.Engine;\nclass Other {}\n")
+        self.assertEqual(self.edges(), {})