tina4-python 3.10.60__tar.gz → 3.10.66__tar.gz

{tina4_python-3.10.60 → tina4_python-3.10.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.10.60
+Version: 3.10.66
 Summary: Tina4 for Python — 54 built-in features, zero dependencies
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.10.60 → tina4_python-3.10.66}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.10.60"
+__version__ = "3.10.66"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.10.60 → tina4_python-3.10.66}/tina4_python/dev_admin/metrics.py

@@ -15,6 +15,11 @@ import hashlib
 from pathlib import Path
 
 
+# ── Scan root tracking ────────────────────────────────────────
+# Stores the resolved root so file_detail() can locate framework files.
+_last_scan_root: str = ""
+
+
 # ── Quick Metrics ──────────────────────────────────────────────
 
 
@@ -24,12 +29,15 @@ def _resolve_root(root: str = "src") -> str:
     If src/ has Python files, scan the user's project code.
     Otherwise, scan the framework itself — so the bubble chart is never empty.
     """
+    global _last_scan_root
     src = Path(root)
     if src.exists() and list(src.rglob("*.py")):
+        _last_scan_root = str(Path(root).resolve())
         return root
     # Fallback: scan the framework package
     import tina4_python
     framework_dir = str(Path(tina4_python.__file__).parent)
+    _last_scan_root = framework_dir
     return framework_dir
 
 
@@ -105,7 +113,7 @@ def quick_metrics(root: str = "src") -> dict:
         total_functions += functions
 
         file_details.append({
-            "path": str(f.relative_to(".")),
+            "path": str(f.relative_to(root_path)),
             "loc": loc,
             "blank": blank,
             "comment": comment,
@@ -211,7 +219,10 @@ def full_analysis(root: str = "src") -> dict:
         except (SyntaxError, OSError):
             continue
 
-        rel_path = str(f.relative_to("."))
+        try:
+            rel_path = str(f.relative_to(root_path))
+        except ValueError:
+            rel_path = str(f.relative_to(root_path.parent)) if root_path.parent != f else f.name
         lines = source.splitlines()
         loc = sum(1 for l in lines if l.strip() and not l.strip().startswith("#"))
 
@@ -327,6 +338,12 @@ def full_analysis(root: str = "src") -> dict:
 def file_detail(file_path: str) -> dict:
     """Detailed metrics for a single file."""
     p = Path(file_path)
+    if not p.exists() and _last_scan_root:
+        # Try resolving relative to the last scan root (framework mode)
+        candidate = Path(_last_scan_root) / file_path
+        if candidate.exists():
+            p = candidate
+            file_path = str(p)
     if not p.exists():
         return {"error": f"File not found: {file_path}"}
 
@@ -495,34 +512,65 @@ def _count_halstead(node: ast.AST, stats: dict):
 def _has_matching_test(rel_path: str) -> bool:
     """Check if a source file has a matching test file.
 
-    Looks for common test file patterns and also scans any test file
-    that imports the module by name.
+    Three-stage detection:
+    1. Filename matching — test_module.py, module_test.py, module_spec.py
+    2. Path matching — any test file referencing the full import path
+    3. Content matching — any test file mentioning the module or class name
     """
+    import re
+
     p = Path(rel_path)
-    module = p.stem  # e.g. "auth" from "tina4_python/auth/__init__.py"
+    module = p.stem  # e.g. "sqlite" from "tina4_python/database/sqlite.py"
     if module == "__init__":
         module = p.parent.name  # use parent dir name
-    # Check common test file patterns
-    test_patterns = [
-        Path("tests") / f"test_{module}.py",
-        Path("tests") / f"test_{module}s.py",
-        Path("test") / f"test_{module}.py",
-        Path("spec") / f"test_{module}.py",
-        Path("tests") / f"{module}_test.py",
+
+    # Build the full dotted import path for deeper matching
+    # e.g. "tina4_python/database/sqlite.py" → "tina4_python.database.sqlite"
+    parts = list(p.with_suffix("").parts)
+    dotted_path = ".".join(parts)  # "tina4_python.database.sqlite"
+
+    # Also track the parent package name for broader matching
+    # e.g. "database" from "tina4_python/database/sqlite.py"
+    parent_module = p.parent.name if len(p.parts) > 1 else ""
+
+    # Stage 1: Filename patterns
+    test_dirs = [Path("tests"), Path("test"), Path("spec")]
+    for td in test_dirs:
+        patterns = [
+            td / f"test_{module}.py",
+            td / f"test_{module}s.py",
+            td / f"{module}_test.py",
+            td / f"{module}_spec.py",
+        ]
+        # Also check parent-named tests (test_database.py covers database/sqlite.py)
+        if parent_module and parent_module != module:
+            patterns.extend([
+                td / f"test_{parent_module}.py",
+                td / f"test_{parent_module}s.py",
+                td / f"{parent_module}_test.py",
+            ])
+        if any(tp.exists() for tp in patterns):
+            return True
+
+    # Stage 2+3: Content scan — check if ANY test file references this module
+    search_terms = [
+        re.compile(rf'\b{re.escape(module)}\b', re.IGNORECASE),
     ]
-    if any(tp.exists() for tp in test_patterns):
-        return True
-    # Grep-based: check if any test file imports this module
-    import re
-    import_patterns = [re.compile(rf'\bimport\s+{re.escape(module)}\b'),
-                       re.compile(rf'\bfrom\s+{re.escape(module)}\b')]
-    for test_dir in (Path("tests"), Path("test"), Path("spec")):
-        if not test_dir.is_dir():
+    # Add dotted path patterns for import matching
+    if dotted_path:
+        search_terms.append(re.compile(rf'{re.escape(dotted_path)}'))
+    # Add class name guesses (CamelCase from snake_case module name)
+    class_name = "".join(w.capitalize() for w in module.split("_"))
+    if class_name != module:
+        search_terms.append(re.compile(rf'\b{re.escape(class_name)}\b'))
+
+    for td in test_dirs:
+        if not td.is_dir():
             continue
-        for test_file in test_dir.glob("*.py"):
+        for test_file in td.rglob("*.py"):
             try:
                 content = test_file.read_text(encoding="utf-8", errors="ignore")
-                if any(pat.search(content) for pat in import_patterns):
+                if any(pat.search(content) for pat in search_terms):
                     return True
             except OSError:
                 pass