baucli 1.0.151__tar.gz → 1.0.152__tar.gz

{baucli-1.0.151 → baucli-1.0.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.151
+Version: 1.0.152
 Summary: Extracts verified business-logic and schema context from Oracle, PostgreSQL, MySQL and SQL Server
 Home-page: https://www.begcloud.com
 Author: BEG Support

{baucli-1.0.151 → baucli-1.0.152}/baucli/__init__.py

@@ -3,6 +3,6 @@
 import warnings
 warnings.filterwarnings("ignore", message="urllib3 v2 only supports OpenSSL")
 
-__version__ = "1.0.151"
+__version__ = "1.0.152"
 __product__ = "BAUCLI"
 __author__ = "BEG Support"

{baucli-1.0.151 → baucli-1.0.152}/baucli/cli.py

@@ -5799,9 +5799,15 @@ def db_profile(db_name, schema, source, tables_csv):
                    "(default: prevoo_<SCHEMA>.pdf na pasta atual).")
 @click.option("--client", "client_name", default=None,
               help="Nome do cliente no cabeçalho do HTML e na capa do PDF (opcional).")
+@click.option("--all-objects", "all_objects", is_flag=True, default=False,
+              help="NÃO desconta os objetos que as regras de nome do BAU tiram da "
+                   "cobertura (_BKP/_TMP/_TESTE…): os números saem do schema inteiro, "
+                   "como até a 1.0.151. Por padrão cada seção conta só o que a carga "
+                   "vai trazer e diz quantos ficaram de fora.")
 def db_check(db_name: str, schema: str, top: int, src_max: int,
              max_cols: int, strict: bool, verbose: bool,
-             fmt: str = "terminal", out_file: str = None, client_name: str = None):
+             fmt: str = "terminal", out_file: str = None, client_name: str = None,
+             all_objects: bool = False):
     """Pré-voo de IA: aponta o que vai dar problema ANTES de documentar.
 
     \b
@@ -6027,6 +6033,97 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                   f"[bold]{schema}[/bold] — esse usuário não enxerga nada desse "
                   f"schema. Provável --db/BAUCLI_HOME errado.[/red]")
 
+    # ── Regras de objeto: avaliadas ANTES das seções ───────────────────────
+    # Responde "quais objetos deste schema o BAU vai classificar como teste/
+    # backup/temp/ferramenta e portanto tirar da cobertura" -- e, desde a
+    # 1.0.152, DESCONTA esses objetos de todas as seções: o pré-voo mede o que
+    # a carga vai trazer, não o schema inteiro (1.040 tabelas sem PK com 300
+    # _BKP dentro era número de susto, não de decisão). --all-objects volta ao
+    # schema inteiro. A seção 7 continua listando os nomes por classe.
+    #
+    # As regras vem do servidor (GET /rules/objects, script 489) em vez de
+    # embutidas aqui: sao editaveis pela UI e escopaveis por tenant/schema, e
+    # uma copia local viraria segunda fonte de verdade que desatualiza em
+    # silencio -- o check diria uma coisa e a carga faria outra.
+    #
+    # A AVALIACAO roda no Oracle DO CLIENTE, com o mesmo LIKE/REGEXP_LIKE(...,'i')
+    # do FNC_BAU_RESOLVE_ARTIFACT_KIND. Reimplementar o match em Python
+    # arriscaria divergir no dialeto de regex. O servidor ja manda `rank` com o
+    # desempate resolvido, entao aqui e so "primeira regra que casa vence"
+    # (ROW_NUMBER por objeto) -- nenhuma precedencia reimplementada.
+    #
+    # BEST-EFFORT: db check e um pre-voo que roda sem licenca e sem servidor.
+    # Sem credencial ou com o BAU fora do ar, nada e descontado, a secao 7 e
+    # PULADA com um aviso e o resto do check segue igual -- o contrato offline
+    # continua valendo (e o veredito diz que os numeros sao do schema inteiro).
+    regras, motivo, _rule_hits = [], None, []
+    try:
+        _api = get_api()
+        if not getattr(_api, "api_key", None):
+            motivo = "sem api key (rode baucli connect)"
+        else:
+            _resp = _api.object_rules(schema) or {}
+            if _resp.get("status") == "ok":
+                regras = _resp.get("rules") or []
+            else:
+                motivo = _resp.get("message") or "resposta inesperada do servidor"
+    except Exception as e:
+        motivo = str(e).splitlines()[0][:70]
+
+    if regras:
+        def _lit(v):
+            return "NULL" if v is None else "'" + str(v).replace("'", "''") + "'"
+        _linhas = " UNION ALL ".join(
+            f"SELECT {r['rank']} rnk, {_lit(r['catalog'])} cat, "
+            f"{_lit(r['match_kind'])} mk, {_lit(r['match_value'])} mv, "
+            f"{_lit(r.get('object_type'))} ot, {_lit(r['artifact_kind'])} ak, "
+            f"{_lit(r['name'])} rname FROM DUAL" for r in regras)
+        _sql_reg = f"""
+        WITH rules AS ({_linhas}),
+        objs AS (
+            SELECT OBJECT_NAME nome, 'PLSQL' cat, OBJECT_TYPE tipo
+              FROM ALL_OBJECTS
+             WHERE OWNER = :o
+               AND OBJECT_TYPE IN ('PACKAGE','PROCEDURE','FUNCTION','TRIGGER','TYPE')
+            UNION ALL
+            SELECT TABLE_NAME, 'TABLE', 'TABLE' FROM ALL_TABLES WHERE OWNER = :o
+            UNION ALL
+            SELECT VIEW_NAME,  'TABLE', 'VIEW'  FROM ALL_VIEWS  WHERE OWNER = :o
+        )
+        SELECT nome, tipo, ak, rname, (SELECT COUNT(*) FROM objs) tot FROM (
+            SELECT o.nome, o.tipo, r.ak, r.rname,
+                   ROW_NUMBER() OVER (PARTITION BY o.cat, o.nome ORDER BY r.rnk) seq
+              FROM objs o
+              JOIN rules r
+                ON (r.cat = 'BOTH' OR r.cat = o.cat)
+               AND (r.ot IS NULL OR UPPER(r.ot) = UPPER(o.tipo))
+               AND ( (r.mk = 'EXACT'    AND UPPER(o.nome) = UPPER(r.mv))
+                  OR (r.mk = 'PREFIX'   AND UPPER(o.nome) LIKE UPPER(r.mv) || '%')
+                  OR (r.mk = 'SUFFIX'   AND UPPER(o.nome) LIKE '%' || UPPER(r.mv))
+                  OR (r.mk = 'CONTAINS' AND UPPER(o.nome) LIKE '%' || UPPER(r.mv) || '%')
+                  OR (r.mk = 'REGEXP'   AND REGEXP_LIKE(o.nome, r.mv, 'i')) )
+        ) WHERE seq = 1 ORDER BY ak, nome"""
+        _rule_hits = _timed(f"regras de objeto ({len(regras)} regras x catalogo)",
+                            _sql_reg, {"o": schema})
+
+    # Conjunto de exclusão NOME -> classe. Vazio = nada é descontado. O nome
+    # basta: PACKAGE BODY e TYPE BODY levam o nome da spec que a regra casou.
+    _excl = {} if all_objects else {str(n).upper(): ak for (n, _t, ak, _r, _tot) in _rule_hits}
+    report["object_rules"].update(
+        applied=bool(_excl),
+        applied_reason=("flag --all-objects" if all_objects
+                        else (None if _excl else (motivo or "nenhuma regra ativa"))))
+
+    def _split_cov(rows, key):
+        """(linhas dentro da cobertura, quantas ficaram fora) pelo nome em row[key]."""
+        if not _excl:
+            return list(rows), 0
+        keep = [r for r in rows if str(r[key] or "").upper() not in _excl]
+        return keep, len(rows) - len(keep)
+
+    def _fora(n):
+        return f" [dim](+{n} fora da cobertura pelas regras)[/dim]" if n else ""
+
     # Tipos que o BAU consegue fatiar: um PACKAGE BODY grande é documentado
     # subprograma a subprograma (chunking DOCPL), então passar do limite da
     # chamada é ESPERADO e tratado — não é impedimento. Um FUNCTION/PROCEDURE/
@@ -6067,6 +6164,7 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
          GROUP BY s.TYPE, s.NAME
          ORDER BY 4 DESC
     """, {"o": schema})
+    plsql_rows, _x_pl = _split_cov(plsql_rows, 1)
     flagged = []
     for (otype, oname, lines, chars) in plsql_rows:
         lvl, why = _band_plsql(otype, int(lines or 0), int(chars or 0))
@@ -6076,14 +6174,14 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
 
     _ord_lvl = {"CRÍTICO": 0, "ATENÇÃO": 1, "AVISO": 2}
     report["plsql"] = {
-        "total": len(plsql_rows),
+        "total": len(plsql_rows), "excluded_by_rules": _x_pl,
         "flagged": [{"level": lvl, "type": otype, "name": oname, "lines": lines,
                      "chars": chars, "tokens": int(chars / CHARS_PER_TOKEN), "reason": why}
                     for (lvl, otype, oname, lines, chars, why)
                     in sorted(flagged, key=lambda r: (_ord_lvl[r[0]], -r[4]))],
     }
-    console.print(f"[bold]PL/SQL[/bold] — {len(plsql_rows)} objeto(s) no schema, "
-                  f"{len(flagged)} sinalizado(s)")
+    console.print(f"[bold]PL/SQL[/bold] — {len(plsql_rows)} objeto(s) na cobertura, "
+                  f"{len(flagged)} sinalizado(s){_fora(_x_pl)}")
     if flagged:
         t = RichTable(show_header=True, header_style="bold", border_style="dim")
         t.add_column("Nível", style="bold")
@@ -6126,13 +6224,15 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
         HAVING COUNT(*) > :mx
          ORDER BY 2 DESC
     """, {"o": schema, "mx": max_cols})
+    wide, _x_wide = _split_cov(wide, 0)
     findings["ATENÇÃO"] += len(wide)
     report["wide_tables"] = {
-        "max_columns": max_cols,
+        "max_columns": max_cols, "excluded_by_rules": _x_wide,
         "items": [{"table": tname, "columns": int(cols), "lobs": int(lobs or 0)}
                   for (tname, cols, lobs) in wide],
     }
-    console.print(f"\n[bold]Tabelas largas[/bold] — {len(wide)} acima de {max_cols} colunas")
+    console.print(f"\n[bold]Tabelas largas[/bold] — {len(wide)} acima de {max_cols} colunas"
+                  f"{_fora(_x_wide)}")
     if wide:
         t = RichTable(show_header=True, header_style="bold", border_style="dim")
         t.add_column("Tabela"); t.add_column("Colunas", justify="right")
@@ -6209,12 +6309,14 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
            AND NOT EXISTS (SELECT 1 FROM mv WHERE mv.MVIEW_NAME = t.TABLE_NAME)
          ORDER BY 3, 4, 1
     """, {"o": schema})
+    no_pk, _x_pk = _split_cov(no_pk, 0)
     sem_id = [r for r in no_pk if int(r[2] or 0) == 0 and int(r[3] or 0) == 0]
     com_id = [r for r in no_pk if r not in sem_id]
     findings["ATENÇÃO"] += len(sem_id)
     findings["AVISO"]   += len(com_id)
     report["no_pk"] = {
         "total": len(no_pk), "no_identity": len(sem_id), "with_unique": len(com_id),
+        "excluded_by_rules": _x_pk,
         "items": [{"table": tname, "columns": int(cols or 0),
                    "rows_est": int(nrows) if nrows is not None else None,
                    "uks": int(uks or 0), "unique_indexes": int(uix or 0),
@@ -6224,7 +6326,7 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
     console.print(f"\n[bold]Tabelas sem PK[/bold] — {len(no_pk)} "
                   f"([red]{len(sem_id)} sem identidade alguma[/red], "
                   f"{len(com_id)} com UK/índice único"
-                  + ")")
+                  + ")" + _fora(_x_pk))
     if no_pk:
         t = RichTable(show_header=True, header_style="bold", border_style="dim")
         t.add_column("Tabela"); t.add_column("Colunas", justify="right")
@@ -6253,14 +6355,15 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
          WHERE v.OWNER = :o AND NVL(v.TEXT_LENGTH,0) > :mx
          ORDER BY 2 DESC
     """, {"o": schema, "mx": src_max})
+    big_views, _x_bv = _split_cov(big_views, 0)
     findings["CRÍTICO"] += len(big_views)
     report["big_views"] = {
-        "limit_chars": src_max,
+        "limit_chars": src_max, "excluded_by_rules": _x_bv,
         "items": [{"view": vname, "chars": int(vlen), "tokens": int(int(vlen) / CHARS_PER_TOKEN)}
                   for (vname, vlen) in big_views],
     }
     console.print(f"\n[bold]Views grandes[/bold] — {len(big_views)} acima de "
-                  f"{src_max:,} chars")
+                  f"{src_max:,} chars{_fora(_x_bv)}")
     if big_views:
         t = RichTable(show_header=True, header_style="bold", border_style="dim")
         t.add_column("View"); t.add_column("Chars", justify="right")
@@ -6288,20 +6391,21 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                                  'TRIGGER','TYPE','TYPE BODY','VIEW')
          ORDER BY o.OBJECT_TYPE, o.OBJECT_NAME
     """, {"o": schema})
+    invalid, _x_inv = _split_cov(invalid, 1)
     broken  = [r for r in invalid if (r[3] or "").strip()]
     stale   = [r for r in invalid if not (r[3] or "").strip()]
     report["invalid"] = {
-        "total": len(invalid),
+        "total": len(invalid), "excluded_by_rules": _x_inv,
         "broken": [{"type": otype, "name": oname, "last_ddl": last_ddl or None,
                     "first_error": (err or "").strip()} for (otype, oname, last_ddl, err) in broken],
         "stale": [{"type": otype, "name": oname, "last_ddl": last_ddl or None}
                   for (otype, oname, last_ddl, _err) in stale],
     }
 
-    if invalid:
-        console.print(f"\n[bold]Objetos INVALID[/bold] — {len(invalid)} no total "
+    if invalid or _x_inv:
+        console.print(f"\n[bold]Objetos INVALID[/bold] — {len(invalid)} na cobertura "
                       f"([red]{len(broken)} quebrado(s)[/red], "
-                      f"{len(stale)} só precisando recompilar)")
+                      f"{len(stale)} só precisando recompilar){_fora(_x_inv)}")
         console.print("  [dim]O sync extrai só STATUS='VALID': qualquer inválido "
                       "fica FORA da documentação.[/dim]")
 
@@ -6362,20 +6466,21 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                             WHERE b.OBJECT_NAME = s.OBJECT_NAME)
          ORDER BY 4 DESC, 1
     """, {"o": schema})
+    nobody, _x_nb = _split_cov(nobody, 0)
     sem_corpo = [r for r in nobody if int(r[3] or 0) > 0]
     so_spec   = [r for r in nobody if int(r[3] or 0) == 0]
     report["packages_no_body"] = {
-        "total": len(nobody),
+        "total": len(nobody), "excluded_by_rules": _x_nb,
         "declaring": [{"package": pname, "subprograms": int(subs or 0),
                        "spec_status": status, "last_ddl": last_ddl or None}
                       for (pname, last_ddl, status, subs) in sem_corpo],
         "spec_only": [r[0] for r in so_spec],
     }
 
-    if nobody:
-        console.print(f"\n[bold]Packages sem BODY[/bold] — {len(nobody)} no total "
+    if nobody or _x_nb:
+        console.print(f"\n[bold]Packages sem BODY[/bold] — {len(nobody)} na cobertura "
                       f"([red]{len(sem_corpo)} declara(m) subprograma[/red], "
-                      f"{len(so_spec)} só constantes/tipos)")
+                      f"{len(so_spec)} só constantes/tipos){_fora(_x_nb)}")
 
     if sem_corpo:
         findings["ATENÇÃO"] += len(sem_corpo)
@@ -6401,88 +6506,25 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                       + "[/dim]")
 
     # ── Regras de objeto: o que o BAU vai marcar como sobra ────────────────
-    # Responde ANTES do 1o sync "quais objetos deste schema o BAU vai
-    # classificar como teste/backup/temp/ferramenta e portanto tirar da
-    # cobertura". Sem isso o usuario so descobre DEPOIS de documentar (p76).
-    #
-    # As regras vem do servidor (GET /rules/objects, script 489) em vez de
-    # embutidas aqui: sao editaveis pela UI e escopaveis por tenant/schema, e
-    # uma copia local viraria segunda fonte de verdade que desatualiza em
-    # silencio -- o check diria uma coisa e a carga faria outra.
-    #
-    # A AVALIACAO roda no Oracle DO CLIENTE, com o mesmo LIKE/REGEXP_LIKE(...,'i')
-    # do FNC_BAU_RESOLVE_ARTIFACT_KIND. Reimplementar o match em Python
-    # arriscaria divergir no dialeto de regex. O servidor ja manda `rank` com o
-    # desempate resolvido, entao aqui e so "primeira regra que casa vence"
-    # (ROW_NUMBER por objeto) -- nenhuma precedencia reimplementada.
-    #
-    # BEST-EFFORT: db check e um pre-voo que roda sem licenca e sem servidor.
-    # Sem credencial ou com o BAU fora do ar, a secao e PULADA com um aviso e
-    # o resto do check segue igual -- o contrato offline continua valendo.
-    regras, motivo = [], None
-    try:
-        _api = get_api()
-        if not getattr(_api, "api_key", None):
-            motivo = "sem api key (rode baucli connect)"
-        else:
-            _resp = _api.object_rules(schema) or {}
-            if _resp.get("status") == "ok":
-                regras = _resp.get("rules") or []
-            else:
-                motivo = _resp.get("message") or "resposta inesperada do servidor"
-    except Exception as e:
-        motivo = str(e).splitlines()[0][:70]
-
+    # A avaliação rodou no início (e descontou as seções acima, salvo
+    # --all-objects); aqui é só a lista por classe, para o cliente conferir.
     if not regras:
         report["object_rules"]["skipped"] = motivo or "nenhuma regra ativa"
         console.print(f"\n[bold]Regras de objetos[/bold] [dim]— pulado: "
-                      f"{motivo or 'nenhuma regra ativa'}[/dim]")
+                      f"{motivo or 'nenhuma regra ativa'}; os números acima são do "
+                      f"schema inteiro[/dim]")
     else:
-        def _lit(v):
-            return "NULL" if v is None else "'" + str(v).replace("'", "''") + "'"
-        _linhas = " UNION ALL ".join(
-            f"SELECT {r['rank']} rnk, {_lit(r['catalog'])} cat, "
-            f"{_lit(r['match_kind'])} mk, {_lit(r['match_value'])} mv, "
-            f"{_lit(r.get('object_type'))} ot, {_lit(r['artifact_kind'])} ak, "
-            f"{_lit(r['name'])} rname FROM DUAL" for r in regras)
-        _sql_reg = f"""
-        WITH rules AS ({_linhas}),
-        objs AS (
-            SELECT OBJECT_NAME nome, 'PLSQL' cat, OBJECT_TYPE tipo
-              FROM ALL_OBJECTS
-             WHERE OWNER = :o
-               AND OBJECT_TYPE IN ('PACKAGE','PROCEDURE','FUNCTION','TRIGGER','TYPE')
-            UNION ALL
-            SELECT TABLE_NAME, 'TABLE', 'TABLE' FROM ALL_TABLES WHERE OWNER = :o
-            UNION ALL
-            SELECT VIEW_NAME,  'TABLE', 'VIEW'  FROM ALL_VIEWS  WHERE OWNER = :o
-        )
-        SELECT nome, tipo, ak, rname, (SELECT COUNT(*) FROM objs) tot FROM (
-            SELECT o.nome, o.tipo, r.ak, r.rname,
-                   ROW_NUMBER() OVER (PARTITION BY o.cat, o.nome ORDER BY r.rnk) seq
-              FROM objs o
-              JOIN rules r
-                ON (r.cat = 'BOTH' OR r.cat = o.cat)
-               AND (r.ot IS NULL OR UPPER(r.ot) = UPPER(o.tipo))
-               AND ( (r.mk = 'EXACT'    AND UPPER(o.nome) = UPPER(r.mv))
-                  OR (r.mk = 'PREFIX'   AND UPPER(o.nome) LIKE UPPER(r.mv) || '%')
-                  OR (r.mk = 'SUFFIX'   AND UPPER(o.nome) LIKE '%' || UPPER(r.mv))
-                  OR (r.mk = 'CONTAINS' AND UPPER(o.nome) LIKE '%' || UPPER(r.mv) || '%')
-                  OR (r.mk = 'REGEXP'   AND REGEXP_LIKE(o.nome, r.mv, 'i')) )
-        ) WHERE seq = 1 ORDER BY ak, nome"""
-        hits = _timed(f"regras de objeto ({len(regras)} regras x catalogo)",
-                      _sql_reg, {"o": schema})
         report["object_rules"].update(source="BAU Server", rules=len(regras))
         console.print(f"\n[bold]Regras de objetos[/bold] [dim]({len(regras)} regras "
                       f"· fonte: BAU Server)[/dim]")
-        if not hits:
+        if not _rule_hits:
             console.print("  [green]Nenhum objeto atingido — tudo entra como "
                           "PROD.[/green]")
         else:
             por_kind = {}
-            for nome, tipo, ak, rname, _tot in hits:
+            for nome, tipo, ak, rname, _tot in _rule_hits:
                 por_kind.setdefault(ak, []).append(nome)
-            total = int(hits[0][4] or 0)
+            total = int(_rule_hits[0][4] or 0)
             report["object_rules"].update(
                 total_objects=total, excluded=sum(len(v) for v in por_kind.values()),
                 by_kind={ak: list(v) for ak, v in sorted(por_kind.items())})
@@ -6494,8 +6536,10 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                               + (f" … +{len(nomes)-len(mostra)}"
                                  if len(nomes) > len(mostra) else ""))
             console.print(f"  [dim]→ {sum(len(v) for v in por_kind.values())} de "
-                          f"{total} objetos sairiam da cobertura como não-PROD "
-                          f"(ARTIFACT_KIND ≠ PROD).[/dim]")
+                          f"{total} objetos saem da cobertura como não-PROD "
+                          f"(ARTIFACT_KIND ≠ PROD)"
+                          + ("; já descontados das seções acima" if _excl
+                             else "; NÃO descontados (--all-objects)") + ".[/dim]")
 
     # ── Codificacao / acentuacao da ORIGEM ────────────────────────────────
     # Por que isto vive no `db check`, ANTES do primeiro sync: banco de cliente
@@ -6574,17 +6618,21 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
             "select 'COLUNA', table_name, column_name, comments from all_col_comments "
             " where owner = :o and comments is not null",
             {"o": schema})
+        # Desconto por ACHADO, não por linha lida: 200 comentários de tabelas
+        # _BKP sem problema nenhum não são "202 fora da cobertura".
+        _src_rows, _x_src = _split_cov(_src_rows, 0)
 
         _cmt_hits = []
         for _k, _tb, _col, _txt in _cmt_rows:
             _sig = _enc_scan(_txt, is_comment=True)
             if _sig:
                 _cmt_hits.append((_k, _tb, _col, ",".join(_sig), _txt))
+        _cmt_hits, _x_cmt = _split_cov(_cmt_hits, 1)
 
         _is_utf8 = str(_charset).upper() in ("AL32UTF8", "UTF8")
         report["encoding"] = {
             "charset": _charset, "ncharset": _cs.get("NLS_NCHAR_CHARACTERSET"),
-            "is_utf8": _is_utf8, "available": True,
+            "is_utf8": _is_utf8, "available": True, "excluded_by_rules": _x_src + _x_cmt,
             "source_objects": [{"name": _n, "type": _ty, "lines": int(_cnt or 0)}
                                for (_n, _ty, _cnt) in _src_rows],
             "comments": [{"where": _k, "table": _tb, "column": _col, "signals": _sig, "text": _txt}
@@ -6690,11 +6738,20 @@ def db_check(db_name: str, schema: str, top: int, src_max: int,
                       f"sem impedimento.[/dim]")
     if not any(findings.values()):
         console.print("[green]● Nada sinalizado — schema dentro dos limites de IA.[/green]")
+    if _excl:
+        console.print(f"[dim]Números da cobertura do BAU: {len(_excl)} objeto(s) fora pelas "
+                      f"regras de nome (seção Regras de objetos). --all-objects mostra o "
+                      f"schema inteiro.[/dim]")
+    elif not all_objects:
+        console.print(f"[dim]Regras de nome não aplicadas ({motivo or 'nenhuma regra ativa'}): "
+                      f"números do schema inteiro.[/dim]")
     console.print("[dim]Próximo passo: baucli sync (ou baucli sync --scope <CODE> "
                  "para recortar o schema).[/dim]")
 
     report["summary"] = {"critico": findings["CRÍTICO"], "atencao": findings["ATENÇÃO"],
-                         "aviso": findings["AVISO"]}
+                         "aviso": findings["AVISO"],
+                         "scope": "cobertura" if _excl else "schema inteiro",
+                         "excluded_by_rules": len(_excl)}
     if _structured:
         console.quiet = False
         tally = (f"[dim]({findings['CRÍTICO']} crítico, {findings['ATENÇÃO']} atenção, "

{baucli-1.0.151 → baucli-1.0.152}/baucli/db_check_pdf.py

@@ -82,6 +82,10 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
     def mono(v):
         return f'<font face="Courier">{_esc(v)}</font>'
 
+    def fora(section):
+        n = int((section or {}).get("excluded_by_rules") or 0)
+        return f' <font color="{_GRAY}">(+{_n(n)} fora da cobertura pelas regras de nome)</font>' if n else ""
+
     def lvl(level):
         color = {"CRÍTICO": _RED, "ATENÇÃO": _AMBER}.get(level or "", _GRAY)
         return f'<font color="{color}"><b>{_esc(level)}</b></font>'
@@ -195,12 +199,19 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
     out.append(P(f"Limiares aplicados: {_n(th.get('source_max_chars'))} caracteres por chamada de IA · tabela até "
                  f"{_esc(th.get('max_columns'))} colunas no prompt · corpo de package com {_n(th.get('lines_unsafe'))} linhas ou "
                  f"mais é edição insegura · fonte dos limiares: {_esc(th.get('source'))}.", "Small"))
+    if orr.get("applied"):
+        out.append(P(f"Números da <b>cobertura do BAU</b>: {_n(s.get('excluded_by_rules'))} objetos classificados como "
+                     "não produtivos pelas regras de nome (seção 7) já foram descontados de todas as seções.", "Small"))
+    else:
+        why = orr.get("applied_reason") or orr.get("skipped")
+        out.append(P("Números do <b>schema inteiro</b>: as regras de nome não foram descontadas"
+                     + (f" ({_esc(why)})" if why else "") + ".", "Small"))
     if not any((crit, aten, aviso)):
         out.append(P("<b>Nada sinalizado</b>: o schema está dentro dos limites de IA."))
 
     # ── 1. PL/SQL ──
     out.append(P("1. Rotinas PL/SQL sinalizadas", "H1"))
-    out.append(P(f"{_n(pl.get('total'))} objetos no schema, <b>{len(pl['flagged'])}</b> sinalizados."))
+    out.append(P(f"{_n(pl.get('total'))} objetos na cobertura, <b>{len(pl['flagged'])}</b> sinalizados.{fora(pl)}"))
     if pl["flagged"]:
         out.append(tbl(["Nível", "Tipo", "Objeto", "Linhas", "KB", "~tokens", "Por quê"],
                        [[lvl(f.get("level")), _esc(f.get("type")), mono(f.get("name")), _n(f.get("lines")),
@@ -212,7 +223,7 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
     out.append(P("2. Tabelas largas", "H1"))
     out.append(P(f"<b>{len(w['items'])}</b> tabelas com mais de {_esc(w.get('max_columns'))} colunas: a IA documenta coluna a "
                  "coluna (fan-out), multiplicando chamadas e revisão. Tabelas com centenas de colunas costumam ser planilhas "
-                 "importadas ou estruturas desnormalizadas; vale confirmar se interessam ao catálogo."))
+                 f"importadas ou estruturas desnormalizadas; vale confirmar se interessam ao catálogo.{fora(w)}"))
     if w["items"]:
         out.append(P("Formato: TABELA (colunas; LOBs quando houver), em ordem decrescente de colunas.", "Small"))
         out.append(compact([f"{i['table']} ({i['columns']}{'; ' + str(i['lobs']) + ' LOB' if i.get('lobs') else ''})"
@@ -222,7 +233,7 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
     out.append(P("3. Tabelas sem chave primária", "H1"))
     out.append(P(f"<b>{_n(npk.get('total'))}</b> tabelas sem PK: {_n(npk.get('no_identity'))} sem nenhuma identidade de linha e "
                  f"{_n(npk.get('with_unique'))} com chave ou índice único (caso leve). Sem chave, formulários e relatórios "
-                 "gerados não têm como apontar o registro e a ordenação de colunas perde o primeiro critério."))
+                 f"gerados não têm como apontar o registro e a ordenação de colunas perde o primeiro critério.{fora(npk)}"))
     com = [i for i in npk["items"] if i.get("has_identity")]
     sem = [i for i in npk["items"] if not i.get("has_identity")]
 
@@ -239,7 +250,7 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
 
     # ── 4. views ──
     out.append(P("4. Views grandes", "H1"))
-    out.append(P(f"{len(bv['items'])} acima de {_n(bv.get('limit_chars'))} caracteres."))
+    out.append(P(f"{len(bv['items'])} acima de {_n(bv.get('limit_chars'))} caracteres.{fora(bv)}"))
     if bv["items"]:
         out.append(tbl(["View", "Chars", "~tokens"],
                        [[mono(i.get("view")), _n(i.get("chars")), _n(i.get("tokens"))] for i in bv["items"]],
@@ -249,7 +260,7 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
     out.append(P("5. Objetos inválidos", "H1"))
     out.append(P(f"<b>{_n(inv.get('total'))}</b> objetos INVALID: {len(inv['broken'])} com erro de compilação e "
                  f"{len(inv['stale'])} invalidados em cascata. O sync extrai só objetos VALID: tudo o que está aqui fica fora "
-                 "da documentação até ser resolvido."))
+                 f"da documentação até ser resolvido.{fora(inv)}"))
     if inv["broken"]:
         out.append(P("Com erro de compilação", "H2"))
         out.append(tbl(["Tipo", "Objeto", "DDL", "1º erro"],
@@ -265,7 +276,7 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
     out.append(P("6. Packages sem corpo", "H1"))
     out.append(P(f"{_n(nb.get('total'))} packages só com especificação: {len(nb['declaring'])} declaram subprogramas sem "
                  "corpo (falham em runtime; a documentação por subprograma fica sem fonte) e "
-                 f"{len(nb['spec_only'])} são só constantes e tipos (legítimo)."))
+                 f"{len(nb['spec_only'])} são só constantes e tipos (legítimo).{fora(nb)}"))
     if nb["declaring"]:
         out.append(tbl(["Package", "Subprogramas", "Spec", "DDL"],
                        [[mono(i.get("package")), _n(i.get("subprograms")), _esc(i.get("spec_status")), _esc(i.get("last_ddl"))]
@@ -280,14 +291,18 @@ def to_pdf(report: dict, client: str | None = None) -> bytes:
         out.append(P(f"Seção pulada: {_esc(orr['skipped'])}.", "Small"))
     else:
         out.append(P(f"{_esc(orr.get('rules'))} regras de nome classificam objetos como não produtivos. "
-                     f"<b>{_n(orr.get('excluded'))}</b> de {_n(orr.get('total_objects'))} objetos saem da cobertura. "
-                     "Confirme se alguma classe está errada para o seu padrão de nomes; a lista é ajustável por cliente."))
+                     f"<b>{_n(orr.get('excluded'))}</b> de {_n(orr.get('total_objects'))} objetos saem da cobertura"
+                     + (", já descontados das seções anteriores. " if orr.get("applied")
+                        else ". Não descontados das seções anteriores. ")
+                     + "Confirme se alguma classe está errada para o seu padrão de nomes; a lista é ajustável por cliente."))
         for kind, names in sorted((orr.get("by_kind") or {}).items()):
             out.append(P(f"{_esc(kind)} ({len(names)})", "H2"))
             out.append(compact(names))
 
     # ── 8. codificação ──
     out.append(P("8. Codificação e acentuação", "H1"))
+    if enc.get("excluded_by_rules"):
+        out.append(P(fora(enc).strip(), "Small"))
     if not enc.get("available", True):
         out.append(P("Checagem indisponível.", "Small"))
     else:

{baucli-1.0.151 → baucli-1.0.152}/baucli/db_check_report.py

@@ -19,7 +19,7 @@ import json
 from datetime import datetime, timezone
 from pathlib import Path
 
-SCHEMA_VERSION = 1
+SCHEMA_VERSION = 2   # 2 (baucli 1.0.152): excluded_by_rules por seção, object_rules.applied, summary.scope
 
 # Logotipo BAU (quadrado preto) embutido como data: URI: o HTML continua um
 # arquivo só, sem recurso externo, e abre com a marca em qualquer lugar.
@@ -41,16 +41,19 @@ def empty_report() -> dict:
         "database": {},          # alias, engine, host, port, service, user
         "schema": None,
         "thresholds": {},        # source_max_chars, max_columns, lines_*, size_*, chars_per_token, source
-        "summary": {"critico": 0, "atencao": 0, "aviso": 0},
-        "plsql": {"total": 0, "flagged": []},
-        "wide_tables": {"max_columns": None, "items": []},
-        "no_pk": {"total": 0, "no_identity": 0, "with_unique": 0, "items": []},
-        "big_views": {"limit_chars": None, "items": []},
-        "invalid": {"total": 0, "broken": [], "stale": []},
-        "packages_no_body": {"total": 0, "declaring": [], "spec_only": []},
+        # scope: "cobertura" (regras de nome descontadas) ou "schema inteiro"
+        "summary": {"critico": 0, "atencao": 0, "aviso": 0, "scope": None, "excluded_by_rules": 0},
+        # excluded_by_rules em cada seção: quantos objetos as regras de nome tiraram dela
+        "plsql": {"total": 0, "excluded_by_rules": 0, "flagged": []},
+        "wide_tables": {"max_columns": None, "excluded_by_rules": 0, "items": []},
+        "no_pk": {"total": 0, "no_identity": 0, "with_unique": 0, "excluded_by_rules": 0, "items": []},
+        "big_views": {"limit_chars": None, "excluded_by_rules": 0, "items": []},
+        "invalid": {"total": 0, "excluded_by_rules": 0, "broken": [], "stale": []},
+        "packages_no_body": {"total": 0, "excluded_by_rules": 0, "declaring": [], "spec_only": []},
         "object_rules": {"source": None, "skipped": None, "rules": 0,
-                         "total_objects": 0, "excluded": 0, "by_kind": {}},
-        "encoding": {"charset": None, "is_utf8": None, "available": True,
+                         "total_objects": 0, "excluded": 0, "by_kind": {},
+                         "applied": False, "applied_reason": None},
+        "encoding": {"charset": None, "is_utf8": None, "available": True, "excluded_by_rules": 0,
                      "source_objects": [], "comments": []},
         "timings": [],
         "errors": [],
@@ -118,6 +121,24 @@ def _cols(items) -> str:
     return '<div class="cols">' + "".join(f"<div>{_e(i)}</div>" for i in items) + "</div>"
 
 
+def _fora(section: dict) -> str:
+    """' (+N fora da cobertura pelas regras)' quando a seção descontou objetos."""
+    n = int((section or {}).get("excluded_by_rules") or 0)
+    return f" <span class='note'>(+{_n(n)} fora da cobertura pelas regras de nome)</span>" if n else ""
+
+
+def _coverage_note(report: dict) -> str:
+    orr = report.get("object_rules") or {}
+    s = report.get("summary") or {}
+    if orr.get("applied"):
+        return (f"<p class='note'>Números da <b>cobertura do BAU</b>: {_n(s.get('excluded_by_rules'))} objetos "
+                "classificados como não produtivos pelas regras de nome (seção 7) já foram descontados de "
+                "todas as seções.</p>")
+    why = orr.get("applied_reason") or orr.get("skipped")
+    return ("<p class='note'>Números do <b>schema inteiro</b>: as regras de nome não foram descontadas"
+            + (f" ({_e(why)})" if why else "") + ".</p>")
+
+
 def to_html(report: dict, client: str | None = None) -> str:
     r = report
     db = r.get("database") or {}
@@ -146,11 +167,12 @@ def to_html(report: dict, client: str | None = None) -> str:
     out.append(f"<p class='note'>Limiares: {_n(th.get('source_max_chars'))} caracteres por chamada de IA · tabela até "
                f"{_e(th.get('max_columns'))} colunas no prompt · corpo de package com {_n(th.get('lines_unsafe'))} linhas "
                f"ou mais é edição insegura · fonte dos limiares: {_e(th.get('source'))}.</p>")
+    out.append(_coverage_note(r))
 
     # PL/SQL
     pl = r["plsql"]
-    out.append(f"<h2>1. Rotinas PL/SQL sinalizadas</h2><p>{_n(pl.get('total'))} objetos no schema, "
-               f"<b>{len(pl['flagged'])}</b> sinalizados.</p>")
+    out.append(f"<h2>1. Rotinas PL/SQL sinalizadas</h2><p>{_n(pl.get('total'))} objetos na cobertura, "
+               f"<b>{len(pl['flagged'])}</b> sinalizados.{_fora(pl)}</p>")
     if pl["flagged"]:
         out.append(_table(["Nível", "Tipo", "Objeto", "Linhas", "KB", "~tokens", "Por quê"],
                           [[_lvl(f["level"]), _e(f["type"]), f"<code>{_e(f['name'])}</code>", _n(f["lines"]),
@@ -160,7 +182,7 @@ def to_html(report: dict, client: str | None = None) -> str:
     # wide
     w = r["wide_tables"]
     out.append(f"<h2>2. Tabelas largas</h2><p><b>{len(w['items'])}</b> tabelas com mais de {_e(w.get('max_columns'))} "
-               "colunas: a IA documenta coluna a coluna (fan-out), multiplicando chamadas e revisão.</p>")
+               f"colunas: a IA documenta coluna a coluna (fan-out), multiplicando chamadas e revisão.{_fora(w)}</p>")
     if w["items"]:
         out.append(_cols([f"{i['table']} ({i['columns']}{'; ' + str(i['lobs']) + ' LOB' if i.get('lobs') else ''})"
                           for i in w["items"]]))
@@ -170,7 +192,7 @@ def to_html(report: dict, client: str | None = None) -> str:
     out.append(f"<h2>3. Tabelas sem chave primária</h2><p><b>{_n(npk.get('total'))}</b> tabelas sem PK: "
                f"{_n(npk.get('no_identity'))} sem nenhuma identidade de linha e {_n(npk.get('with_unique'))} com chave "
                "ou índice único (caso leve). Sem chave, formulários e relatórios gerados não têm como apontar o registro "
-               "e a ordenação de colunas perde o primeiro critério.</p>")
+               f"e a ordenação de colunas perde o primeiro critério.{_fora(npk)}</p>")
     com = [i for i in npk["items"] if i.get("has_identity")]
     sem = [i for i in npk["items"] if not i.get("has_identity")]
     fmt = lambda i: f"{i['table']} ({i['columns']} col, {_n(i['rows_est']) if i.get('rows_est') is not None else '—'} lin)"
@@ -181,7 +203,7 @@ def to_html(report: dict, client: str | None = None) -> str:
 
     # views
     bv = r["big_views"]
-    out.append(f"<h2>4. Views grandes</h2><p>{len(bv['items'])} acima de {_n(bv.get('limit_chars'))} caracteres.</p>")
+    out.append(f"<h2>4. Views grandes</h2><p>{len(bv['items'])} acima de {_n(bv.get('limit_chars'))} caracteres.{_fora(bv)}</p>")
     if bv["items"]:
         out.append(_table(["View", "Chars", "~tokens"],
                           [[f"<code>{_e(i['view'])}</code>", _n(i["chars"]), _n(i["tokens"])] for i in bv["items"]],
@@ -191,7 +213,7 @@ def to_html(report: dict, client: str | None = None) -> str:
     inv = r["invalid"]
     out.append(f"<h2>5. Objetos inválidos</h2><p><b>{_n(inv.get('total'))}</b> objetos INVALID: {len(inv['broken'])} com "
                f"erro de compilação e {len(inv['stale'])} invalidados em cascata. O sync extrai só objetos VALID: tudo "
-               "o que está aqui fica fora da documentação até ser resolvido.</p>")
+               f"o que está aqui fica fora da documentação até ser resolvido.{_fora(inv)}</p>")
     if inv["broken"]:
         out.append("<h3>Com erro de compilação</h3>" + _table(
             ["Tipo", "Objeto", "DDL", "1º erro"],
@@ -204,7 +226,7 @@ def to_html(report: dict, client: str | None = None) -> str:
     nb = r["packages_no_body"]
     out.append(f"<h2>6. Packages sem corpo</h2><p>{_n(nb.get('total'))} packages só com especificação: "
                f"{len(nb['declaring'])} declaram subprogramas sem corpo (falham em runtime; a documentação por "
-               f"subprograma fica sem fonte) e {len(nb['spec_only'])} são só constantes e tipos (legítimo).</p>")
+               f"subprograma fica sem fonte) e {len(nb['spec_only'])} são só constantes e tipos (legítimo).{_fora(nb)}</p>")
     if nb["declaring"]:
         out.append(_table(["Package", "Subprogramas", "Spec", "DDL"],
                           [[f"<code>{_e(i['package'])}</code>", _n(i["subprograms"]), _e(i["spec_status"]), _e(i["last_ddl"])]
@@ -219,13 +241,17 @@ def to_html(report: dict, client: str | None = None) -> str:
         out.append(f"<p class='note'>Seção pulada: {_e(orr['skipped'])}.</p>")
     else:
         out.append(f"<p>{_e(orr.get('rules'))} regras de nome classificam objetos como não produtivos. "
-                   f"<b>{_n(orr.get('excluded'))}</b> de {_n(orr.get('total_objects'))} objetos saem da cobertura.</p>")
+                   f"<b>{_n(orr.get('excluded'))}</b> de {_n(orr.get('total_objects'))} objetos saem da cobertura"
+                   + (", já descontados das seções anteriores." if orr.get("applied")
+                      else ". Não descontados das seções anteriores.") + "</p>")
         for kind, names in sorted((orr.get("by_kind") or {}).items()):
             out.append(f"<h3>{_e(kind)} ({len(names)})</h3>" + _cols(names))
 
     # encoding
     enc = r["encoding"]
     out.append("<h2>8. Codificação e acentuação</h2>")
+    if enc.get("excluded_by_rules"):
+        out.append(f"<p class='note'>{_fora(enc).strip()}</p>")
     if not enc.get("available", True):
         out.append("<p class='note'>Checagem indisponível.</p>")
     else:

{baucli-1.0.151 → baucli-1.0.152}/baucli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: baucli
-Version: 1.0.151
+Version: 1.0.152
 Summary: Extracts verified business-logic and schema context from Oracle, PostgreSQL, MySQL and SQL Server
 Home-page: https://www.begcloud.com
 Author: BEG Support

{baucli-1.0.151 → baucli-1.0.152}/tests/test_db_check_pdf.py

@@ -41,5 +41,5 @@ def test_text_content_when_pypdf_available():
     text = "\n".join(p.extract_text() for p in reader.pages)
     for name in ("NAC_PCK_MKT_CAMPANHA", "NAC_RH_CST_GESTAX", "AD_ORG_BKP", "BEG_FNC_RETORNA_IPI",
                  "NAC_PRC_B2B_REC_ITENS", "PCK_IMPORTACAO_MULTINAC", "PKG_URLS", "NAC_TMP", "FNC_LIMPA_STR",
-                 "BEG_CPG_RENEG", "Ziz Performance", "WE8ISO8859P1"):
+                 "BEG_CPG_RENEG", "Ziz Performance", "WE8ISO8859P1", "fora da cobertura"):
         assert name in text, name

{baucli-1.0.151 → baucli-1.0.152}/tests/test_db_check_report.py

@@ -12,12 +12,12 @@ def _sample():
                      "port": 1521, "service": "multisc", "user": "COMPIERE"}
     r["thresholds"] = {"source_max_chars": 50000, "max_columns": 30, "lines_unsafe": 6000,
                        "chars_per_token": 4.0, "source": "BAU Server"}
-    r["summary"] = {"critico": 1, "atencao": 2, "aviso": 1}
-    r["plsql"] = {"total": 10, "flagged": [
+    r["summary"] = {"critico": 1, "atencao": 2, "aviso": 1, "scope": "cobertura", "excluded_by_rules": 2}
+    r["plsql"] = {"total": 10, "excluded_by_rules": 1, "flagged": [
         {"level": "CRÍTICO", "type": "PACKAGE BODY", "name": "NAC_PCK_MKT_CAMPANHA",
          "lines": 27898, "chars": 1291000, "tokens": 322750, "reason": "edição por IA insegura"}]}
     r["wide_tables"] = {"max_columns": 30, "items": [{"table": "NAC_RH_CST_GESTAX", "columns": 614, "lobs": 0}]}
-    r["no_pk"] = {"total": 2, "no_identity": 1, "with_unique": 1, "items": [
+    r["no_pk"] = {"total": 2, "no_identity": 1, "with_unique": 1, "excluded_by_rules": 1, "items": [
         {"table": "AD_ORG_BKP", "columns": 14, "rows_est": 67, "uks": 0, "unique_indexes": 0, "has_identity": False},
         {"table": "BAU_CONFIG", "columns": 9, "rows_est": None, "uks": 1, "unique_indexes": 0, "has_identity": True}]}
     r["invalid"] = {"total": 2,
@@ -28,7 +28,8 @@ def _sample():
         {"package": "PCK_IMPORTACAO_MULTINAC", "subprograms": 26, "spec_status": "VALID", "last_ddl": "09/01/25 08:36"}],
         "spec_only": ["PKG_URLS"]}
     r["object_rules"] = {"source": "BAU Server", "skipped": None, "rules": 31, "total_objects": 6522,
-                         "excluded": 2, "by_kind": {"BACKUP": ["AD_ORG_BKP"], "TEMP": ["NAC_TMP"]}}
+                         "excluded": 2, "by_kind": {"BACKUP": ["AD_ORG_BKP"], "TEMP": ["NAC_TMP"]},
+                         "applied": True, "applied_reason": None}
     r["encoding"] = {"charset": "WE8ISO8859P1", "is_utf8": False, "available": True,
                      "source_objects": [{"name": "FNC_LIMPA_STR", "type": "FUNCTION", "lines": 16}],
                      "comments": [{"where": "COLUNA", "table": "BEG_CPG_RENEG", "column": "NAME",
@@ -42,10 +43,23 @@ def test_json_roundtrip_keeps_everything():
     r = _sample()
     back = json.loads(to_json(r))
     assert back["schema_version"] == SCHEMA_VERSION
-    assert back["summary"] == {"critico": 1, "atencao": 2, "aviso": 1}
+    assert back["summary"] == {"critico": 1, "atencao": 2, "aviso": 1, "scope": "cobertura", "excluded_by_rules": 2}
     assert back["plsql"]["flagged"][0]["name"] == "NAC_PCK_MKT_CAMPANHA"
     assert back["no_pk"]["items"][1]["rows_est"] is None
     assert back["object_rules"]["by_kind"]["TEMP"] == ["NAC_TMP"]
+    assert back["summary"]["scope"] == "cobertura" and back["no_pk"]["excluded_by_rules"] == 1
+
+
+def test_html_says_whether_rules_were_discounted():
+    html = to_html(_sample())
+    assert "cobertura do BAU" in html and "já descontados" in html
+    assert "(+1 fora da cobertura pelas regras de nome)" in html
+    r = empty_report()
+    r["object_rules"]["applied_reason"] = "flag --all-objects"
+    html = to_html(r)
+    # o título da seção 7 sempre diz "fora da cobertura"; o que não pode aparecer é o desconto por seção
+    assert "schema inteiro" in html and "flag --all-objects" in html
+    assert "fora da cobertura pelas regras de nome)" not in html
 
 
 def test_empty_report_has_every_section():