sourcecode 1.9.0__tar.gz → 1.11.0__tar.gz

{sourcecode-1.9.0 → sourcecode-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.9.0
+Version: 1.11.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -357,5 +357,3 @@ Generates task-specific context for AI agents.
 | `refactor` | Structural problems, improvement opportunities | 🧪 EXP |
 | `generate-tests` | Files without tests, coverage gap analysis | 🧪 EXP |
 | `review-pr` | Changed files + architectural impact | 🧪 EXP |
-
-...

{sourcecode-1.9.0 → sourcecode-1.11.0}/README.md

@@ -138,5 +138,3 @@ Generates task-specific context for AI agents.
 | `refactor` | Structural problems, improvement opportunities | 🧪 EXP |
 | `generate-tests` | Files without tests, coverage gap analysis | 🧪 EXP |
 | `review-pr` | Changed files + architectural impact | 🧪 EXP |
-
-...

{sourcecode-1.9.0 → sourcecode-1.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.9.0"
+version = "1.11.0"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.9.0 → sourcecode-1.11.0}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.9.0"
+__version__ = "1.11.0"

{sourcecode-1.9.0 → sourcecode-1.11.0}/src/sourcecode/cli.py

@@ -629,6 +629,10 @@ def main(
         )
         raise typer.Exit(code=1)
 
+    if symbol is not None and not symbol.strip():
+        typer.echo("symbol query cannot be empty", err=True)
+        raise typer.Exit(code=2)
+
     if symbol and mode not in ("contract", "standard"):
         typer.echo(
             f"Error: --symbol requires --mode contract or standard (got '{mode}'). "

{sourcecode-1.9.0 → sourcecode-1.11.0}/src/sourcecode/prepare_context.py

@@ -563,6 +563,25 @@ class TaskContextBuilder:
         except Exception:
             pass
 
+        # ── 5c. review-pr suspected_areas (needs git uncommitted_files) ──────
+        if task_name == "review-pr" and spec.enable_code_notes:
+            pr_areas: dict[str, int] = {}
+            for path in uncommitted_files:
+                pr_areas[path] = pr_areas.get(path, 0) + 10
+            review_kinds = {"FIXME", "TODO", "BUG", "HACK"}
+            for note in cn_notes_for_ranking:
+                if note.kind in review_kinds:
+                    pr_areas[note.path] = pr_areas.get(note.path, 0) + 1
+            _BOOST_STEMS = ("Controller", "Service", "Repository", "Mapper", "Filter", "Security")
+            for path in all_paths:
+                stem = Path(path).stem
+                if any(k in stem for k in _BOOST_STEMS):
+                    pr_areas[path] = pr_areas.get(path, 0) + 2
+            suspected_areas = [
+                p for p, _ in sorted(pr_areas.items(), key=lambda x: -x[1])[:8]
+                if not self._is_test(p)
+            ]
+
         # ── 6. Rank files ──────────────────────────────────────────────────
         entry_set = {ep.path for ep in entry_points}
         test_set = {p for p in all_paths if self._is_test(p)}

{sourcecode-1.9.0 → sourcecode-1.11.0}/src/sourcecode/serializer.py

@@ -38,6 +38,19 @@ _MONOREPO_PKGS_CAP = 8       # max workspace/runtime packages shown
 _KEY_DEPS_CAP = 50           # max key dependencies shown
 _CODE_NOTES_CAP = 15         # max code notes in default output
 _ENV_MAP_CAP = 15            # max env var entries in default output
+_MAX_DEFAULT_CONTRACTS = 20  # max contracts in default/standard contract output
+_MAX_HARD_SIGNALS_DEFAULT = 20  # max hard_signals entries in default output
+
+
+def _cap_contracts_for_output(
+    contracts: list[Any],
+    max_count: int = _MAX_DEFAULT_CONTRACTS,
+) -> tuple[list[Any], dict[str, Any]]:
+    """Sort contracts by relevance_score desc, cap to max_count, return (sampled, meta)."""
+    total = len(contracts)
+    sampled = sorted(contracts, key=lambda c: getattr(c, "relevance_score", 0.0), reverse=True)[:max_count]
+    meta: dict[str, Any] = {"total": total, "shown": len(sampled), "truncated": total > max_count}
+    return sampled, meta
 
 
 def to_json(sm: SourceMap | dict[str, Any], indent: int = 2) -> str:
@@ -191,6 +204,178 @@ def _dep_import_key(name: str) -> str:
     return lowered.split("/")[0].replace("_", "-")
 
 
+# ---------------------------------------------------------------------------
+# Java/Spring compact-mode helpers (v1.10.0)
+# ---------------------------------------------------------------------------
+
+def _compact_git_context(sm: "SourceMap") -> "Optional[dict[str, Any]]":
+    """Lightweight git_context for compact/agent output. Top-5 hotspots only."""
+    gc = sm.git_context
+    if gc is None or not gc.requested:
+        return None
+    _bad = {"no_git_repo", "git_not_found", "git_timeout"}
+    if _bad & set(gc.limitations):
+        return None
+    ctx: dict[str, Any] = {}
+    if gc.branch:
+        ctx["branch"] = gc.branch
+    if gc.uncommitted_changes is not None:
+        uc = gc.uncommitted_changes
+        ctx["uncommitted_files"] = len(uc.staged) + len(uc.unstaged) + len(uc.untracked)
+    if gc.change_hotspots:
+        ctx["top_hotspots"] = [
+            {"file": h.file, "commits": h.commit_count}
+            for h in gc.change_hotspots[:5]
+        ]
+    return ctx if ctx else None
+
+
+def _dep_risk_flags(name: str, version: "Optional[str]") -> list[str]:
+    """Static heuristic risk flags for a single dependency. No external lookups."""
+    flags: list[str] = []
+    nl = name.lower()
+    if "spring-boot" in nl or "spring.boot" in nl:
+        if version and version.startswith("2."):
+            flags.append("spring-boot-2.x-eol")
+    if nl.startswith("javax.") or nl == "javax":
+        flags.append("javax-to-jakarta-migration-risk")
+    if "ojdbc" in nl or nl in {"com.oracle.database.jdbc", "oracle.jdbc.driver.oracledriver"}:
+        flags.append("oracle-vendor-lock")
+    return flags
+
+
+def _project_deployment_risks(sm: "SourceMap") -> list[str]:
+    """Project-level deployment risk flags derived from Java version and app server."""
+    risks: list[str] = []
+    lv = sm.language_version or ""
+    if lv in ("1.8", "8", "1.7", "7"):
+        risks.append("legacy-java-runtime")
+    if getattr(sm, "app_server_hint", None) == "weblogic" and getattr(sm, "packaging", None) == "war":
+        risks.append("legacy-app-server-deployment")
+    return risks
+
+
+def _mybatis_pairing(sm: "SourceMap") -> "Optional[dict[str, Any]]":
+    """Lightweight MyBatis mapper interface <-> XML file pairing from file_paths."""
+    from pathlib import Path as _Path
+    has_mybatis = any(
+        any(f.name.lower() == "mybatis" for f in s.frameworks)
+        for s in sm.stacks
+    )
+    if not has_mybatis:
+        return None
+    non_test = [p for p in sm.file_paths if "/test/" not in p and "/tests/" not in p]
+    mapper_interfaces = [p for p in non_test if p.endswith("Mapper.java")]
+    xml_files = [p for p in sm.file_paths if p.endswith("Mapper.xml")]
+    interface_index = {_Path(p).stem: p for p in mapper_interfaces}
+    xml_index = {_Path(p).stem: p for p in xml_files}
+    orphan_xml = [xml_index[s] for s in xml_index if s not in interface_index]
+    missing_xml = [s for s in interface_index if s not in xml_index]
+    result: dict[str, Any] = {
+        "mapper_interfaces": len(mapper_interfaces),
+        "xml_files": len(xml_files),
+    }
+    if orphan_xml:
+        result["orphan_xml"] = orphan_xml[:5]
+    if missing_xml:
+        result["missing_xml"] = missing_xml[:5]
+    return result
+
+
+def _security_surface_from_eps(eps: list) -> "Optional[dict[str, Any]]":
+    """Extract @M3FiltroSeguridad resource names from entry point evidence strings."""
+    import re as _re
+    _NOMBRE_RE = _re.compile(r"nombreRecurso=[\"']([^\"']+)[\"']")
+    resource_names: list[str] = []
+    seen: set[str] = set()
+    for ep in eps:
+        evidence = getattr(ep, "evidence", None)
+        if not evidence:
+            continue
+        for m in _NOMBRE_RE.finditer(evidence):
+            nm = m.group(1)
+            if nm and nm not in seen:
+                seen.add(nm)
+                resource_names.append(nm)
+    return {"resource_names": resource_names} if resource_names else None
+
+
+def _bootstrap_structured(eps: list) -> "Optional[dict[str, Any]]":
+    """Separate Java entry points into bootstrap / security / controllers groups."""
+    from pathlib import Path as _Path
+    bootstrap: list[str] = []
+    security: list[str] = []
+    controllers: list[dict] = []
+    seen_b: set[str] = set()
+    seen_s: set[str] = set()
+    seen_c: set[str] = set()
+
+    for ep in eps:
+        path = getattr(ep, "path", "")
+        kind = getattr(ep, "kind", "")
+        stem = _Path(path).stem
+
+        if kind == "application" or any(k in stem for k in ("Application", "Main", "Initializer", "Bootstrap")):
+            if path not in seen_b:
+                seen_b.add(path)
+                bootstrap.append(path)
+        elif kind == "filter" or any(k in stem for k in ("Filter", "Security", "Auth", "Jwt", "WebSecurity")):
+            if path not in seen_s:
+                seen_s.add(path)
+                security.append(path)
+        elif kind in ("rest_controller", "mvc_controller"):
+            if path not in seen_c:
+                seen_c.add(path)
+                item: dict[str, Any] = {"path": path}
+                http_path = getattr(ep, "http_path", None)
+                if http_path:
+                    item["http_path"] = http_path
+                controllers.append(item)
+
+    if not bootstrap and not security:
+        return None
+
+    result: dict[str, Any] = {}
+    if bootstrap:
+        result["bootstrap"] = bootstrap
+    if security:
+        result["security"] = security
+    if controllers:
+        result["controllers"] = {
+            "count": len(controllers),
+            "sample": [{"path": c["path"]} for c in controllers[:5]],
+        }
+    return result
+
+
+def _lightweight_arch_pattern(sm: "SourceMap") -> "Optional[dict[str, Any]]":
+    """Heuristic architecture pattern from directory names alone."""
+    if not sm.file_paths:
+        return None
+    dir_names: set[str] = set()
+    for p in sm.file_paths:
+        for part in p.replace("\\", "/").split("/")[:-1]:
+            dir_names.add(part.lower())
+
+    has_controller = bool({"controller", "controllers", "api", "rest", "web", "handler", "handlers"} & dir_names)
+    has_service = bool({"service", "services", "usecase", "usecases", "application"} & dir_names)
+    has_repository = bool({"repository", "repositories", "repo", "repos", "dao", "persistence"} & dir_names)
+    has_domain = bool({"domain", "domains", "core", "model", "models", "entity", "entities"} & dir_names)
+    has_infra = bool({"infrastructure", "infra", "adapter", "adapters"} & dir_names)
+
+    if has_controller and has_service and has_repository and has_domain:
+        return {"pattern": "ddd-layered", "confidence": 0.72 if has_infra else 0.55}
+    if bool({"ports", "port"} & dir_names) and bool({"adapter", "adapters"} & dir_names):
+        return {"pattern": "hexagonal-like", "confidence": 0.65}
+    if has_controller and bool({"model", "models", "entity", "entities"} & dir_names):
+        return {"pattern": "mvc", "confidence": 0.55}
+    if has_controller and has_service and has_repository:
+        return {"pattern": "layered", "confidence": 0.70}
+    if has_controller and has_service:
+        return {"pattern": "layered", "confidence": 0.42}
+    return None
+
+
 def _file_relevance(sm: SourceMap, *, limit: int = _FILE_RELEVANCE_LIMIT) -> list[dict[str, Any]]:
     from sourcecode.ranking_engine import RankingEngine
 
@@ -300,7 +485,20 @@ def _architecture_context(sm: SourceMap) -> dict[str, Any]:
     arch = sm.architecture
     if arch is not None and arch.requested:
         pattern = arch.pattern if arch.pattern not in (None, "unknown", "flat") else None
-        ctx: dict[str, Any] = {
+        if not pattern:
+            _hint = _lightweight_arch_pattern(sm)
+            if _hint:
+                ctx: dict[str, Any] = {
+                    "summary": sm.architecture_summary,
+                    "pattern": _hint["pattern"],
+                    "confidence": arch.confidence,
+                    "pattern_confidence": _hint["confidence"],
+                    "method": arch.method,
+                }
+                if arch.limitations:
+                    ctx["limitations"] = arch.limitations
+                return ctx
+        ctx = {
             "summary": sm.architecture_summary,
             "pattern": pattern or "insufficient_evidence",
             "confidence": arch.confidence,
@@ -326,6 +524,18 @@ def _architecture_context(sm: SourceMap) -> dict[str, Any]:
         if arch.limitations:
             ctx["limitations"] = arch.limitations
         return ctx
+    _hint = _lightweight_arch_pattern(sm)
+    if _hint:
+        return {
+            "summary": sm.architecture_summary,
+            "pattern": _hint["pattern"],
+            "pattern_confidence": _hint["confidence"],
+            "confidence": "low",
+            "method": "filesystem_heuristic",
+            "limitations": [
+                "architecture analyzer not requested; pattern inferred from directory names only"
+            ],
+        }
     return {
         "summary": sm.architecture_summary,
         "pattern": "insufficient_evidence",
@@ -382,18 +592,23 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
 
     Excludes: file_tree, raw dependency lists, docs, module_graph, verbose metadata.
     """
-    # Key dependencies — name + version + role only (no ecosystem, source, manifests)
+    # Key dependencies — name + version + role + risk_flags
     key_deps: Any = None
     if sm.dependency_summary is not None and sm.dependency_summary.requested:
-        key_deps = [
-            {
-                "name": d.name,
-                **({"version": d.declared_version} if d.declared_version else {}),
-                **({"role": d.role} if d.role and d.role != "runtime" else {}),
-            }
-            for d in sm.key_dependencies
-            if (d.role or "unknown") in _PRODUCTION_DEP_ROLES and d.scope not in {"dev"}
-        ][:_KEY_DEPS_CAP]
+        key_deps = []
+        for d in sm.key_dependencies:
+            if (d.role or "unknown") not in _PRODUCTION_DEP_ROLES or d.scope in {"dev"}:
+                continue
+            entry: dict[str, Any] = {"name": d.name}
+            if d.declared_version:
+                entry["version"] = d.declared_version
+            if d.role and d.role != "runtime":
+                entry["role"] = d.role
+            flags = _dep_risk_flags(d.name, d.declared_version)
+            if flags:
+                entry["risk_flags"] = flags
+            key_deps.append(entry)
+        key_deps = key_deps[:_KEY_DEPS_CAP]
 
     # Dependency summary — requested flag + count + source only
     dep_summary_dict: Any = None
@@ -452,16 +667,20 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
                 for n in _sorted_notes[:_CODE_NOTES_CAP]
             ]
 
-    # Entry points — path + kind + confidence only
+    # Entry points — bootstrap-prioritized; structured when bootstrap classes detected
     ep_groups = _entry_point_groups(sm.entry_points)
-    entry_points_compact = [
-        {
-            "path": ep["path"],
-            **({"kind": ep["kind"]} if ep.get("kind") else {}),
-            **({"confidence": ep["confidence"]} if ep.get("confidence") else {}),
-        }
-        for ep in ep_groups["production"][:_EP_PRODUCTION_CAP]
-    ]
+    _bootstrap_struct = _bootstrap_structured(sm.entry_points)
+    if _bootstrap_struct:
+        entry_points_compact: Any = _bootstrap_struct
+    else:
+        entry_points_compact = [
+            {
+                "path": ep["path"],
+                **({"kind": ep["kind"]} if ep.get("kind") else {}),
+                **({"confidence": ep["confidence"]} if ep.get("confidence") else {}),
+            }
+            for ep in ep_groups["production"][:_EP_PRODUCTION_CAP]
+        ]
 
     # Stacks — name + method + confidence + frameworks (names only)
     stacks_compact = [
@@ -492,6 +711,22 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
             for g in sm.analysis_gaps
         ]
 
+    # Java/Spring operational context
+    _language_version = getattr(sm, "language_version", None)
+    _packaging = getattr(sm, "packaging", None)
+    _app_server = getattr(sm, "app_server_hint", None)
+    _deployment: Any = None
+    if _packaging or _app_server:
+        _deployment = {}
+        if _packaging:
+            _deployment["packaging"] = _packaging
+        if _app_server:
+            _deployment["app_server_hint"] = _app_server
+    _deploy_risks = _project_deployment_risks(sm)
+    _security_surface = _security_surface_from_eps(sm.entry_points)
+    _mybatis = _mybatis_pairing(sm)
+    _git_ctx = _compact_git_context(sm)
+
     result: dict[str, Any] = {
         "schema_version": sm.metadata.schema_version,
         "project_type": sm.project_type,
@@ -508,6 +743,18 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
         "confidence_summary": conf_dict,
         "analysis_gaps": gaps_list,
     }
+    if _language_version:
+        result["language_version"] = _language_version
+    if _deployment:
+        result["deployment"] = _deployment
+    if _deploy_risks:
+        result["deployment_risks"] = _deploy_risks
+    if _security_surface:
+        result["security_surface"] = _security_surface
+    if _mybatis:
+        result["mybatis"] = _mybatis
+    if _git_ctx:
+        result["git_context"] = _git_ctx
     _always_include = {"project_type", "project_summary", "architecture_summary", "dependency_summary"}
     return {k: v for k, v in result.items() if v is not None or k in _always_include}
 
@@ -825,15 +1072,34 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
     if secondary:
         project["secondary_stacks"] = sorted({s.stack for s in secondary})
 
+    # Java operational context in project block
+    _lv = getattr(sm, "language_version", None)
+    _pkg = getattr(sm, "packaging", None)
+    _app_srv = getattr(sm, "app_server_hint", None)
+    if _lv:
+        project["language_version"] = _lv
+    if _pkg or _app_srv:
+        _depl: dict[str, Any] = {}
+        if _pkg:
+            _depl["packaging"] = _pkg
+        if _app_srv:
+            _depl["app_server_hint"] = _app_srv
+        project["deployment"] = _depl
+    _proj_risks = _project_deployment_risks(sm)
+    if _proj_risks:
+        project["deployment_risks"] = _proj_risks
+
     result: dict[str, Any] = {"project": project}
 
-    # ── 2. Entry points: production/runtime only, capped ─────────────────────
-    # Auxiliary entries are not actionable for agents — omitted entirely.
-    # Development entries shown in a separate channel, capped.
-    ep_groups = _entry_point_groups(sm.entry_points)
-    result["entry_points"] = ep_groups["production"][:_EP_PRODUCTION_CAP]
-    if ep_groups["development"]:
-        result["development_entry_points"] = ep_groups["development"][:_EP_DEV_CAP]
+    # ── 2. Entry points: bootstrap-prioritized, then production ─────────────
+    _bs = _bootstrap_structured(sm.entry_points)
+    if _bs:
+        result["entry_points"] = _bs
+    else:
+        ep_groups = _entry_point_groups(sm.entry_points)
+        result["entry_points"] = ep_groups["production"][:_EP_PRODUCTION_CAP]
+        if ep_groups["development"]:
+            result["development_entry_points"] = ep_groups["development"][:_EP_DEV_CAP]
 
     # ── 3. Architecture ───────────────────────────────────────────────────────
     result["architecture"] = _architecture_context(sm)
@@ -863,17 +1129,21 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
         if dep_groups[dep_key]:
             result[dep_key] = dep_groups[dep_key][:_SECONDARY_DEPS_CAP]
 
-    # Backward-compatible compact list, now production-only.
+    # Backward-compatible compact list, now production-only, with risk_flags.
     production_key_deps = [
         d for d in sm.key_dependencies
         if (d.role or "unknown") in _PRODUCTION_DEP_ROLES and d.scope not in {"dev"}
     ]
     if sm.dependency_summary and sm.dependency_summary.requested and production_key_deps:
         _dep_skip = {"parent", "manifest_path", "workspace", "source", "ecosystem"}
-        result["key_dependencies"] = [
-            {k: v for k, v in asdict(d).items() if v is not None and k not in _dep_skip}
-            for d in production_key_deps[:_KEY_DEPS_CAP]
-        ]
+        _kd_list = []
+        for d in production_key_deps[:_KEY_DEPS_CAP]:
+            item = {k: v for k, v in asdict(d).items() if v is not None and k not in _dep_skip}
+            flags = _dep_risk_flags(d.name, d.declared_version)
+            if flags:
+                item["risk_flags"] = flags
+            _kd_list.append(item)
+        result["key_dependencies"] = _kd_list
 
     # ── 5. Signals — compact operational context ─────────────────────────────
     signals: dict[str, Any] = {}
@@ -945,9 +1215,22 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
             sem_info["hotspots"] = sem.hotspots[:10]
         signals["semantic_graph"] = sem_info
 
+    # Java/Spring: security surface and ORM structure
+    _sec_surf = _security_surface_from_eps(sm.entry_points)
+    if _sec_surf:
+        signals["security_surface"] = _sec_surf
+    _mb = _mybatis_pairing(sm)
+    if _mb:
+        signals["mybatis"] = _mb
+
     if signals:
         result["signals"] = signals
 
+    # Git context — lightweight (top-5 hotspots, branch, uncommitted count)
+    _gc = _compact_git_context(sm)
+    if _gc:
+        result["git_context"] = _gc
+
     # ── 6. Confidence summary ─────────────────────────────────────────────────
     if sm.confidence_summary is not None:
         cs = sm.confidence_summary
@@ -1230,13 +1513,11 @@ def _contract_view_minimal(
     if getattr(sm, "app_server_hint", None):
         result["app_server_hint"] = sm.app_server_hint
 
-    # Per-file contracts
+    # Per-file contracts — capped to avoid token bloat on large projects
     if contracts:
-        serialized: list[dict[str, Any]] = []
-        for c in contracts:
-            item = _serialize_contract_minimal(c)
-            serialized.append(item)
-        result["contracts"] = serialized
+        _capped, _meta = _cap_contracts_for_output(contracts)
+        result["contracts"] = [_serialize_contract_minimal(c) for c in _capped]
+        result["contracts_meta"] = _meta
 
     # Optional analysis sections — included when the analyzer explicitly ran
     # (user passed --dependencies, --env-map, --code-notes, --git-context)
@@ -1587,10 +1868,11 @@ def _contract_view_standard(
             "stack": sm.confidence_summary.stack_confidence,
         }
 
-    # Per-file contracts (full detail)
+    # Per-file contracts (full detail) — capped to avoid token bloat on large projects
     if contracts:
+        _capped, _meta = _cap_contracts_for_output(contracts)
         serialized: list[dict[str, Any]] = []
-        for c in contracts:
+        for c in _capped:
             if getattr(c, "language", None) == "mybatis-xml":
                 item = _serialize_contract_mybatis_xml(c)
                 item["relevance_score"] = round(c.relevance_score, 3)
@@ -1646,6 +1928,7 @@ def _contract_view_standard(
             item["method"] = c.extraction_method
             serialized.append(item)
         result["contracts"] = serialized
+        result["contracts_meta"] = _meta
 
     # Optional analysis sections (deep mode or when analyzers ran)
     if include_optional:

sourcecode-1.11.0/tests/fixtures/spring_boot_minimal/src/main/java/com/example/demo/config/FilterConfig.java

@@ -0,0 +1,17 @@
+package com.example.demo.config;
+
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class FilterConfig {
+
+    @Bean
+    public FilterRegistrationBean<SecurityFilter> securityFilter() {
+        FilterRegistrationBean<SecurityFilter> bean = new FilterRegistrationBean<>();
+        bean.setFilter(new SecurityFilter());
+        bean.addUrlPatterns("/*");
+        return bean;
+    }
+}

sourcecode-1.11.0/tests/fixtures/spring_boot_minimal/src/main/java/com/example/demo/web/NominaRestController.java

@@ -0,0 +1,16 @@
+package com.example.demo.web;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/nominas")
+@M3FiltroSeguridad(nombreRecurso = "nominas")
+public class NominaRestController {
+
+    @GetMapping
+    public String list() {
+        return "[]";
+    }
+}

sourcecode-1.11.0/tests/fixtures/spring_boot_minimal/src/main/resources/mapper/HealthMapper.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.example.demo.mapper.HealthMapper">
+    <select id="findStatus" parameterType="long" resultType="String">
+        SELECT status FROM health WHERE id = #{id}
+    </select>
+</mapper>