fix: address remaining SonarQube code quality issues

Author: nikolay-e

src/treemapper/cli.py

@@ -34,7 +34,7 @@ def _validate_budget(budget: int | None) -> None:
 
 
 def _validate_alpha(alpha: float) -> None:
-    if alpha <= 0 or alpha >= 1:
+    if not (0 < alpha < 1):
         _exit_error(f"--alpha must be between 0 and 1 (exclusive), got {alpha}")
 
 

src/treemapper/diffctx/edges/config/terraform.py

@@ -120,9 +120,7 @@ def discover_related_files(
         for candidate in all_candidate_files:
             if candidate in changed_set or not _is_terraform_file(candidate):
                 continue
-            if candidate.parent in tf_dirs:
-                discovered.append(candidate)
-            elif _is_in_module(candidate, module_sources, tf_dirs):
+            if candidate.parent in tf_dirs or _is_in_module(candidate, module_sources, tf_dirs):
                 discovered.append(candidate)
 
         return discovered
@@ -221,24 +219,49 @@ def _build_module_source_edges(
         path_to_frags = build_path_to_frags(all_frags, repo_root)
 
         for f in tf_frags:
-            base_dir = f.path.parent
-
-            for match in _TF_SOURCE_RE.finditer(f.content):
-                source = match.group(1)
-
-                if source.startswith("./") or source.startswith("../"):
-                    module_dir = (base_dir / source).resolve()
-                    for p, frag_ids in path_to_frags.items():
-                        try:
-                            if p.is_absolute():
-                                resolved = p.resolve()
-                            elif repo_root:
-                                resolved = (repo_root / p).resolve()
-                            else:
-                                resolved = p
-                            if resolved.parent == module_dir or str(resolved).startswith(str(module_dir)):
-                                for frag_id in frag_ids:
-                                    if frag_id != f.id:
-                                        self.add_edge(edges, f.id, frag_id, self.weight * 0.8)
-                        except (ValueError, OSError):
-                            continue
+            self._link_module_sources(f, path_to_frags, edges, repo_root)
+
+    def _link_module_sources(
+        self,
+        f: Fragment,
+        path_to_frags: dict[Path, list[FragmentId]],
+        edges: EdgeDict,
+        repo_root: Path | None,
+    ) -> None:
+        base_dir = f.path.parent
+
+        for match in _TF_SOURCE_RE.finditer(f.content):
+            source = match.group(1)
+            if source.startswith("./") or source.startswith("../"):
+                module_dir = (base_dir / source).resolve()
+                self._link_files_in_module_dir(f, module_dir, path_to_frags, edges, repo_root)
+
+    def _link_files_in_module_dir(
+        self,
+        f: Fragment,
+        module_dir: Path,
+        path_to_frags: dict[Path, list[FragmentId]],
+        edges: EdgeDict,
+        repo_root: Path | None,
+    ) -> None:
+        for p, frag_ids in path_to_frags.items():
+            resolved = self._resolve_path(p, repo_root)
+            if resolved is None:
+                continue
+            if self._is_in_module_dir(resolved, module_dir):
+                for frag_id in frag_ids:
+                    if frag_id != f.id:
+                        self.add_edge(edges, f.id, frag_id, self.weight * 0.8)
+
+    def _resolve_path(self, p: Path, repo_root: Path | None) -> Path | None:
+        try:
+            if p.is_absolute():
+                return p.resolve()
+            if repo_root:
+                return (repo_root / p).resolve()
+            return p
+        except (ValueError, OSError):
+            return None
+
+    def _is_in_module_dir(self, resolved: Path, module_dir: Path) -> bool:
+        return resolved.parent == module_dir or str(resolved).startswith(str(module_dir))

src/treemapper/diffctx/edges/semantic/dotnet.py

@@ -154,44 +154,60 @@ def _link_usings(
         edges: EdgeDict,
     ) -> None:
         for using in _extract_usings(df.content, df.path):
-            using_lower = using.lower()
-            for fid in namespace_to_frags.get(using_lower, []):
-                if fid != df.id:
-                    self.add_edge(edges, df.id, fid, self.using_weight)
+            self._link_single_using(df.id, using, namespace_to_frags, fqn_to_frags, type_to_frags, edges)
 
-            for fid in fqn_to_frags.get(using_lower, []):
-                if fid != df.id:
-                    self.add_edge(edges, df.id, fid, self.using_weight)
+    def _link_single_using(
+        self,
+        df_id: FragmentId,
+        using: str,
+        namespace_to_frags: dict[str, list[FragmentId]],
+        fqn_to_frags: dict[str, list[FragmentId]],
+        type_to_frags: dict[str, list[FragmentId]],
+        edges: EdgeDict,
+    ) -> None:
+        using_lower = using.lower()
+        self._add_edges_from_index(df_id, namespace_to_frags.get(using_lower, []), self.using_weight, edges)
+        self._add_edges_from_index(df_id, fqn_to_frags.get(using_lower, []), self.using_weight, edges)
 
-            parts = using.split(".")
-            if parts:
-                for fid in type_to_frags.get(parts[-1].lower(), []):
-                    if fid != df.id:
-                        self.add_edge(edges, df.id, fid, self.using_weight)
+        parts = using.split(".")
+        if parts:
+            self._add_edges_from_index(df_id, type_to_frags.get(parts[-1].lower(), []), self.using_weight, edges)
+
+    def _add_edges_from_index(self, source_id: FragmentId, target_ids: list[FragmentId], weight: float, edges: EdgeDict) -> None:
+        for fid in target_ids:
+            if fid != source_id:
+                self.add_edge(edges, source_id, fid, weight)
 
     def _link_refs(
         self,
         df: Fragment,
         type_to_frags: dict[str, list[FragmentId]],
         edges: EdgeDict,
     ) -> None:
-        for parent in _extract_inheritance(df.content):
-            for fid in type_to_frags.get(parent.lower(), []):
-                if fid != df.id:
-                    self.add_edge(edges, df.id, fid, self.inheritance_weight)
+        self._link_inheritance(df.id, df.content, type_to_frags, edges)
+        self._link_type_refs(df.id, df.content, type_to_frags, edges)
+        self._link_attributes(df.id, df.content, type_to_frags, edges)
 
-        for type_ref in _extract_type_refs(df.content):
-            for fid in type_to_frags.get(type_ref.lower(), []):
-                if fid != df.id:
-                    self.add_edge(edges, df.id, fid, self.type_weight)
+    def _link_inheritance(
+        self, df_id: FragmentId, content: str, type_to_frags: dict[str, list[FragmentId]], edges: EdgeDict
+    ) -> None:
+        for parent in _extract_inheritance(content):
+            self._add_edges_from_index(df_id, type_to_frags.get(parent.lower(), []), self.inheritance_weight, edges)
 
-        for attr in _extract_attributes(df.content):
+    def _link_type_refs(
+        self, df_id: FragmentId, content: str, type_to_frags: dict[str, list[FragmentId]], edges: EdgeDict
+    ) -> None:
+        for type_ref in _extract_type_refs(content):
+            self._add_edges_from_index(df_id, type_to_frags.get(type_ref.lower(), []), self.type_weight, edges)
+
+    def _link_attributes(
+        self, df_id: FragmentId, content: str, type_to_frags: dict[str, list[FragmentId]], edges: EdgeDict
+    ) -> None:
+        for attr in _extract_attributes(content):
             attr_lower = attr.lower()
             attr_full = attr_lower if attr_lower.endswith("attribute") else attr_lower + "attribute"
             for lookup in [attr_lower, attr_full]:
-                for fid in type_to_frags.get(lookup, []):
-                    if fid != df.id:
-                        self.add_edge(edges, df.id, fid, self.attribute_weight)
+                self._add_edges_from_index(df_id, type_to_frags.get(lookup, []), self.attribute_weight, edges)
 
     def _link_same_namespace(
         self,

src/treemapper/diffctx/edges/semantic/go.py

@@ -133,18 +133,36 @@ def _link_imports(
         edges: EdgeDict,
     ) -> None:
         for imp in imports:
-            imp_pkg = imp.split("/")[-1]
-            for pkg, frag_ids in pkg_to_frags.items():
-                if pkg == imp_pkg:
-                    for fid in frag_ids:
-                        if fid != gf.id:
-                            self.add_edge(edges, gf.id, fid, self.import_weight)
-
-            for path_str, frag_ids in path_to_frags.items():
-                if imp in path_str or imp.endswith(path_str):
-                    for fid in frag_ids:
-                        if fid != gf.id:
-                            self.add_edge(edges, gf.id, fid, self.import_weight)
+            self._link_import_by_package(gf.id, imp, pkg_to_frags, edges)
+            self._link_import_by_path(gf.id, imp, path_to_frags, edges)
+
+    def _link_import_by_package(
+        self,
+        gf_id: FragmentId,
+        imp: str,
+        pkg_to_frags: dict[str, list[FragmentId]],
+        edges: EdgeDict,
+    ) -> None:
+        imp_pkg = imp.split("/")[-1]
+        for pkg, frag_ids in pkg_to_frags.items():
+            if pkg == imp_pkg:
+                self._add_edges_from_ids(gf_id, frag_ids, self.import_weight, edges)
+
+    def _link_import_by_path(
+        self,
+        gf_id: FragmentId,
+        imp: str,
+        path_to_frags: dict[str, list[FragmentId]],
+        edges: EdgeDict,
+    ) -> None:
+        for path_str, frag_ids in path_to_frags.items():
+            if imp in path_str or imp.endswith(path_str):
+                self._add_edges_from_ids(gf_id, frag_ids, self.import_weight, edges)
+
+    def _add_edges_from_ids(self, source_id: FragmentId, target_ids: list[FragmentId], weight: float, edges: EdgeDict) -> None:
+        for fid in target_ids:
+            if fid != source_id:
+                self.add_edge(edges, source_id, fid, weight)
 
     def _link_refs(
         self,

src/treemapper/diffctx/edges/semantic/javascript.py

@@ -14,7 +14,8 @@
 _JS_SYMBOL_REF_WEIGHT = 0.75
 _JS_TYPE_REF_WEIGHT = 0.65
 
-_JS_IMPORT_RE = re.compile(r"""import\s+[^'"]*['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\)""")
+_JS_IMPORT_STATIC_RE = re.compile(r"""import\s+[^'"]*['"]([^'"]+)['"]""")
+_JS_REQUIRE_RE = re.compile(r"""require\s*\(\s*['"]([^'"]+)['"]\s*\)""")
 _JS_EXPORT_FROM_RE = re.compile(r"""export\s+.*?\s+from\s+['"]([^'"]+)['"]""")
 
 
@@ -53,15 +54,17 @@ def _normalize_import(imp: str, source_path: Path) -> set[str]:
 def _extract_imports_from_content(content: str, source_path: Path) -> set[str]:
     imports: set[str] = set()
 
-    for match in _JS_IMPORT_RE.finditer(content):
-        imp = match.group(1) or match.group(2)
-        if imp:
-            imports.update(_normalize_import(imp, source_path))
+    for match in _JS_IMPORT_STATIC_RE.finditer(content):
+        if match.group(1):
+            imports.update(_normalize_import(match.group(1), source_path))
+
+    for match in _JS_REQUIRE_RE.finditer(content):
+        if match.group(1):
+            imports.update(_normalize_import(match.group(1), source_path))
 
     for match in _JS_EXPORT_FROM_RE.finditer(content):
-        imp = match.group(1)
-        if imp:
-            imports.update(_normalize_import(imp, source_path))
+        if match.group(1):
+            imports.update(_normalize_import(match.group(1), source_path))
 
     return imports
 

src/treemapper/diffctx/edges/semantic/php.py

@@ -193,16 +193,22 @@ def _add_use_edges(self, pf_id: FragmentId, uses: set[str], idx: _PHPIndex, edge
 
     def _add_require_edges(self, pf_id: FragmentId, requires: set[str], idx: _PHPIndex, edges: EdgeDict) -> None:
         for req in requires:
-            req_name = req.split("/")[-1].replace(".php", "").lower()
-            for fid in idx.name_to_frags.get(req_name, []):
-                if fid != pf_id:
-                    self.add_edge(edges, pf_id, fid, self.require_weight)
-
-            for path_str, frag_ids in idx.path_to_frags.items():
-                if req in path_str:
-                    for fid in frag_ids:
-                        if fid != pf_id:
-                            self.add_edge(edges, pf_id, fid, self.require_weight)
+            self._link_require_by_name(pf_id, req, idx, edges)
+            self._link_require_by_path(pf_id, req, idx, edges)
+
+    def _link_require_by_name(self, pf_id: FragmentId, req: str, idx: _PHPIndex, edges: EdgeDict) -> None:
+        req_name = req.split("/")[-1].replace(".php", "").lower()
+        self._add_edges_from_ids(pf_id, idx.name_to_frags.get(req_name, []), self.require_weight, edges)
+
+    def _link_require_by_path(self, pf_id: FragmentId, req: str, idx: _PHPIndex, edges: EdgeDict) -> None:
+        for path_str, frag_ids in idx.path_to_frags.items():
+            if req in path_str:
+                self._add_edges_from_ids(pf_id, frag_ids, self.require_weight, edges)
+
+    def _add_edges_from_ids(self, source_id: FragmentId, target_ids: list[FragmentId], weight: float, edges: EdgeDict) -> None:
+        for fid in target_ids:
+            if fid != source_id:
+                self.add_edge(edges, source_id, fid, weight)
 
     def _add_inheritance_edges(self, pf_id: FragmentId, inheritance: set[str], idx: _PHPIndex, edges: EdgeDict) -> None:
         for parent in inheritance:

src/treemapper/diffctx/edges/semantic/python.py

@@ -47,6 +47,14 @@ def discover_related_files(
         if not py_changed:
             return []
 
+        changed_modules = self._collect_changed_modules(py_changed, repo_root)
+        if not changed_modules:
+            return []
+
+        changed_set = set(changed_files)
+        return self._find_files_importing_modules(all_candidate_files, changed_set, changed_modules)
+
+    def _collect_changed_modules(self, py_changed: list[Path], repo_root: Path | None) -> set[str]:
         changed_modules: set[str] = set()
         for f in py_changed:
             module = path_to_module(f, repo_root)
@@ -55,32 +63,27 @@ def discover_related_files(
                 parts = module.split(".")
                 for i in range(1, len(parts) + 1):
                     changed_modules.add(".".join(parts[:i]))
+        return changed_modules
 
-        if not changed_modules:
-            return []
-
+    def _find_files_importing_modules(
+        self, all_candidate_files: list[Path], changed_set: set[Path], changed_modules: set[str]
+    ) -> list[Path]:
         discovered: list[Path] = []
-        changed_set = set(changed_files)
-
         for candidate in all_candidate_files:
-            if candidate in changed_set:
-                continue
-            if not _is_python_file(candidate):
-                continue
-
-            try:
-                content = candidate.read_text(encoding="utf-8")
-                imports = _extract_imports_from_content(content)
-
-                for imp in imports:
-                    if imp in changed_modules:
-                        discovered.append(candidate)
-                        break
-            except (OSError, UnicodeDecodeError):
+            if candidate in changed_set or not _is_python_file(candidate):
                 continue
-
+            if self._imports_any_module(candidate, changed_modules):
+                discovered.append(candidate)
         return discovered
 
+    def _imports_any_module(self, candidate: Path, changed_modules: set[str]) -> bool:
+        try:
+            content = candidate.read_text(encoding="utf-8")
+            imports = _extract_imports_from_content(content)
+            return any(imp in changed_modules for imp in imports)
+        except (OSError, UnicodeDecodeError):
+            return False
+
     def build(self, fragments: list[Fragment], repo_root: Path | None = None) -> EdgeDict:
         py_frags = [f for f in fragments if f.path.suffix.lower() == ".py"]
         if not py_frags:

src/treemapper/diffctx/edges/semantic/ruby.py

@@ -165,16 +165,22 @@ def _add_fragment_edges(self, rf: Fragment, idx: _RubyIndex, edges: EdgeDict, re
 
     def _add_require_edges(self, rf_id: FragmentId, requires: set[str], idx: _RubyIndex, edges: EdgeDict) -> None:
         for req in requires:
-            req_name = req.split("/")[-1].lower()
-            for fid in idx.name_to_frags.get(req_name, []):
-                if fid != rf_id:
-                    self.add_edge(edges, rf_id, fid, self.require_weight)
-
-            for path_str, frag_ids in idx.path_to_frags.items():
-                if req in path_str or req.replace("/", "\\") in path_str:
-                    for fid in frag_ids:
-                        if fid != rf_id:
-                            self.add_edge(edges, rf_id, fid, self.require_weight)
+            self._link_require_by_name(rf_id, req, idx, edges)
+            self._link_require_by_path(rf_id, req, idx, edges)
+
+    def _link_require_by_name(self, rf_id: FragmentId, req: str, idx: _RubyIndex, edges: EdgeDict) -> None:
+        req_name = req.split("/")[-1].lower()
+        self._add_edges_from_ids(rf_id, idx.name_to_frags.get(req_name, []), self.require_weight, edges)
+
+    def _link_require_by_path(self, rf_id: FragmentId, req: str, idx: _RubyIndex, edges: EdgeDict) -> None:
+        for path_str, frag_ids in idx.path_to_frags.items():
+            if req in path_str or req.replace("/", "\\") in path_str:
+                self._add_edges_from_ids(rf_id, frag_ids, self.require_weight, edges)
+
+    def _add_edges_from_ids(self, source_id: FragmentId, target_ids: list[FragmentId], weight: float, edges: EdgeDict) -> None:
+        for fid in target_ids:
+            if fid != source_id:
+                self.add_edge(edges, source_id, fid, weight)
 
     def _add_relative_require_edges(
         self,