codehealthanalyzer 1.2.2__tar.gz → 1.2.4__tar.gz

{codehealthanalyzer-1.2.2/codehealthanalyzer.egg-info → codehealthanalyzer-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codehealthanalyzer
-Version: 1.2.2
+Version: 1.2.4
 Summary: Biblioteca Python para análise de qualidade e saúde de código
 Home-page: https://github.com/imparcialista/codehealthanalyzer
 Author: Luarco Team

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4}/codehealthanalyzer/analyzers/violations.py

@@ -121,7 +121,7 @@ class ViolationsAnalyzer(BaseAnalyzer):
         doc_lines = self._python_docstring_lines(tree)
         count = 0
         try:
-            with open(file_path, "r", encoding="utf-8") as fh:
+            with open(file_path, "r", encoding="utf-8-sig") as fh:
                 for idx, raw in enumerate(fh, 1):
                     stripped = raw.strip()
                     if not stripped or stripped.startswith("#"):
@@ -150,7 +150,7 @@ class ViolationsAnalyzer(BaseAnalyzer):
 
     def _count_html_lines(self, file_path: Path) -> int:
         try:
-            with open(file_path, "r", encoding="utf-8") as fh:
+            with open(file_path, "r", encoding="utf-8-sig") as fh:
                 return sum(1 for line in fh if line.strip())
         except OSError as exc:
             logger.warning("Falha ao ler template %s: %s", file_path, exc)
@@ -192,7 +192,7 @@ class ViolationsAnalyzer(BaseAnalyzer):
         if file_path.suffix == ".py":
             result["type"] = "Python"
             try:
-                with open(file_path, "r", encoding="utf-8") as fh:
+                with open(file_path, "r", encoding="utf-8-sig") as fh:
                     source = fh.read()
                 tree = ast.parse(source, filename=str(file_path))
             except (OSError, SyntaxError) as exc:

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4}/codehealthanalyzer/cli/main.py

@@ -129,11 +129,31 @@ def _write_report_files(
     base_name: str,
     format_name: str,
     no_json: bool,
+    detail: str = "full",
 ) -> None:
     formatter = ReportFormatter()
     output_path.mkdir(parents=True, exist_ok=True)
+
     if not no_json:
-        formatter.to_json(report, str(output_path / f"{base_name}.json"))
+        summary_report = _build_summary_report(report)
+        if detail == "summary":
+            formatter.to_json(summary_report, str(output_path / f"{base_name}.json"))
+            formatter.to_json(
+                summary_report, str(output_path / f"{base_name}.summary.json")
+            )
+        elif detail == "standard":
+            formatter.to_json(
+                _build_standard_report(report), str(output_path / f"{base_name}.json")
+            )
+            formatter.to_json(
+                summary_report, str(output_path / f"{base_name}.summary.json")
+            )
+        else:
+            formatter.to_json(report, str(output_path / f"{base_name}.json"))
+            formatter.to_json(report, str(output_path / f"{base_name}.full.json"))
+            formatter.to_json(
+                summary_report, str(output_path / f"{base_name}.summary.json")
+            )
     if format_name in ["html", "all"]:
         ReportGenerator().generate_html_report(
             report, str(output_path / f"{base_name}.html")
@@ -144,6 +164,136 @@ def _write_report_files(
         formatter.to_csv(report, str(output_path / f"{base_name}.csv"))
 
 
+def _write_analyze_json_files(
+    report: FullReport,
+    output_path: Path,
+    detail: str,
+) -> None:
+    formatter = ReportFormatter()
+    summary_report = _build_summary_report(report)
+
+    # Arquivos base amigaveis para consumo humano e integracoes simples.
+    formatter.to_json(summary_report, str(output_path / "summary_report.json"))
+    formatter.to_json(
+        report.get("violations", {}), str(output_path / "violations_report.json")
+    )
+    formatter.to_json(
+        report.get("templates", {}), str(output_path / "templates_report.json")
+    )
+    formatter.to_json(report.get("errors", {}), str(output_path / "errors_report.json"))
+
+    if detail in ["standard", "full"]:
+        formatter.to_json(
+            _build_standard_report(report), str(output_path / "analysis_report.json")
+        )
+
+    # Relatorio completo agora e opcional e so e gerado explicitamente.
+    if detail == "full":
+        formatter.to_json(report, str(output_path / "full_report.json"))
+
+
+def _build_summary_report(report: FullReport, top_n: int = 10) -> dict[str, Any]:
+    violations = report.get("violations", {})
+    templates = report.get("templates", {})
+    errors = report.get("errors", {})
+    return {
+        "metadata": report.get("metadata", {}),
+        "summary": report.get("summary", {}),
+        "priorities": report.get("priorities", []),
+        "top_violations": (violations.get("violations", []) or [])[:top_n],
+        "top_warnings": (violations.get("warnings", []) or [])[:top_n],
+        "top_templates": (templates.get("templates", []) or [])[:top_n],
+        "top_errors": (errors.get("errors", []) or [])[:top_n],
+    }
+
+
+def _standardize_violation_items(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    for item in items:
+        messages = item.get("violations", []) or []
+        out.append(
+            {
+                "file": item.get("file", ""),
+                "type": item.get("type", ""),
+                "lines": item.get("lines", 0),
+                "priority": item.get("priority", "low"),
+                "violation_count": len(messages),
+                "sample_violations": messages[:5],
+            }
+        )
+    return out
+
+
+def _standardize_templates(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    for item in items:
+        out.append(
+            {
+                "file": item.get("file", ""),
+                "priority": item.get("priority", "low"),
+                "category": item.get("category", ""),
+                "total_css_chars": item.get("total_css_chars", item.get("css", 0)),
+                "total_js_chars": item.get("total_js_chars", item.get("js", 0)),
+                "css_inline_count": len(item.get("css_inline", []) or []),
+                "css_style_tags_count": len(item.get("css_style_tags", []) or []),
+                "js_inline_count": len(item.get("js_inline", []) or []),
+                "js_script_tags_count": len(item.get("js_script_tags", []) or []),
+            }
+        )
+    return out
+
+
+def _standardize_errors(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    for item in items:
+        details = item.get("errors", []) or []
+        out.append(
+            {
+                "file": item.get("file", ""),
+                "priority": item.get("priority", "low"),
+                "category": item.get("category", ""),
+                "error_count": item.get("error_count", len(details)),
+                "sample_errors": details[:5],
+            }
+        )
+    return out
+
+
+def _build_standard_report(report: FullReport) -> dict[str, Any]:
+    violations = report.get("violations", {})
+    templates = report.get("templates", {})
+    errors = report.get("errors", {})
+
+    # Compatibilidade com Python 3.8: evitar generics PEP585 em runtime dentro de cast().
+    violation_items = cast(list, violations.get("violations", []) or [])
+    warning_items = cast(list, violations.get("warnings", []) or [])
+    template_items = cast(list, templates.get("templates", []) or [])
+    error_items = cast(list, errors.get("errors", []) or [])
+
+    return {
+        "metadata": report.get("metadata", {}),
+        "summary": report.get("summary", {}),
+        "quality_score": report.get("quality_score", 0),
+        "priorities": report.get("priorities", []),
+        "violations": {
+            "metadata": violations.get("metadata", {}),
+            "statistics": violations.get("statistics", {}),
+            "violations": _standardize_violation_items(violation_items),
+            "warnings": _standardize_violation_items(warning_items),
+        },
+        "templates": {
+            "metadata": templates.get("metadata", {}),
+            "statistics": templates.get("statistics", {}),
+            "templates": _standardize_templates(template_items),
+        },
+        "errors": {
+            "metadata": errors.get("metadata", {}),
+            "statistics": errors.get("statistics", {}),
+            "errors": _standardize_errors(error_items),
+        },
+    }
+
+
 @click.group()
 @click.version_option(version=__version__)
 def cli():
@@ -177,6 +327,13 @@ def cli():
     help="Formato do relatório (além do JSON padrão)",
 )
 @click.option("--no-json", is_flag=True, help="Não gerar o relatório JSON padrão")
+@click.option(
+    "--detail",
+    type=click.Choice(["summary", "standard", "full"]),
+    default="standard",
+    show_default=True,
+    help="Nível de detalhe (full_report.json é gerado apenas em 'full')",
+)
 @click.option(
     "--config", "-c", type=click.Path(exists=True), help="Arquivo de configuração JSON"
 )
@@ -191,6 +348,7 @@ def analyze(
     output: Optional[str],
     format: str,
     no_json: bool,
+    detail: str,
     config: Optional[str],
     no_default_excludes: bool,
     verbose: bool,
@@ -274,7 +432,12 @@ def analyze(
 
         # Diretório de saída padrão
         output_path = Path(output or "reports")
-        _write_report_files(report, output_path, "full_report", format, no_json)
+        output_path.mkdir(parents=True, exist_ok=True)
+        if not no_json:
+            _write_analyze_json_files(report, output_path, detail)
+        _write_report_files(
+            report, output_path, "analysis_report", format, no_json=True, detail=detail
+        )
 
         click.echo("\n" + ColorHelper.success("Análise concluída com sucesso!"))
 

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4}/codehealthanalyzer/version.py

@@ -1,3 +1,3 @@
 """Versionamento central do pacote."""
 
-__version__ = "1.2.2"
+__version__ = "1.2.4"

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4/codehealthanalyzer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codehealthanalyzer
-Version: 1.2.2
+Version: 1.2.4
 Summary: Biblioteca Python para análise de qualidade e saúde de código
 Home-page: https://github.com/imparcialista/codehealthanalyzer
 Author: Luarco Team

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4}/tests/test_cli.py

@@ -60,7 +60,12 @@ def test_analyze_runs_on_valid_project(runner, project, tmp_path):
             ["analyze", str(project), "--output", str(out), "--no-default-excludes"],
         )
     assert result.exit_code == 0
-    assert (out / "full_report.json").exists()
+    assert (out / "summary_report.json").exists()
+    assert (out / "analysis_report.json").exists()
+    assert (out / "violations_report.json").exists()
+    assert (out / "templates_report.json").exists()
+    assert (out / "errors_report.json").exists()
+    assert not (out / "full_report.json").exists()
 
 
 def test_analyze_json_report_has_summary(runner, project, tmp_path):
@@ -70,7 +75,7 @@ def test_analyze_json_report_has_summary(runner, project, tmp_path):
             cli,
             ["analyze", str(project), "--output", str(out), "--no-default-excludes"],
         )
-    report = json.loads((out / "full_report.json").read_text(encoding="utf-8"))
+    report = json.loads((out / "summary_report.json").read_text(encoding="utf-8"))
     assert "summary" in report
     assert "quality_score" in report["summary"]
 
@@ -100,7 +105,7 @@ def test_analyze_markdown_format(runner, project, tmp_path):
                 "--no-default-excludes",
             ],
         )
-    assert (out / "full_report.md").exists()
+    assert (out / "analysis_report.md").exists()
 
 
 def test_analyze_no_json_flag(runner, project, tmp_path):
@@ -117,7 +122,62 @@ def test_analyze_no_json_flag(runner, project, tmp_path):
                 "--no-default-excludes",
             ],
         )
+    assert not (out / "summary_report.json").exists()
+    assert not (out / "analysis_report.json").exists()
+    assert not (out / "violations_report.json").exists()
+    assert not (out / "templates_report.json").exists()
+    assert not (out / "errors_report.json").exists()
+
+
+def test_analyze_detail_summary_generates_summary_files(runner, project, tmp_path):
+    out = tmp_path / "out"
+    with patch("shutil.which", return_value=None):
+        runner.invoke(
+            cli,
+            [
+                "analyze",
+                str(project),
+                "--output",
+                str(out),
+                "--detail",
+                "summary",
+                "--no-default-excludes",
+            ],
+        )
+
+    assert (out / "summary_report.json").exists()
+    assert (out / "violations_report.json").exists()
+    assert (out / "templates_report.json").exists()
+    assert (out / "errors_report.json").exists()
+    assert not (out / "analysis_report.json").exists()
     assert not (out / "full_report.json").exists()
+    data = json.loads((out / "summary_report.json").read_text(encoding="utf-8"))
+    assert "summary" in data
+    assert "top_violations" in data
+
+
+def test_analyze_detail_full_generates_full_alias_file(runner, project, tmp_path):
+    out = tmp_path / "out"
+    with patch("shutil.which", return_value=None):
+        runner.invoke(
+            cli,
+            [
+                "analyze",
+                str(project),
+                "--output",
+                str(out),
+                "--detail",
+                "full",
+                "--no-default-excludes",
+            ],
+        )
+
+    assert (out / "summary_report.json").exists()
+    assert (out / "analysis_report.json").exists()
+    assert (out / "violations_report.json").exists()
+    assert (out / "templates_report.json").exists()
+    assert (out / "errors_report.json").exists()
+    assert (out / "full_report.json").exists()
 
 
 # ---------------------------------------------------------------------------

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4}/tests/test_cli_contract.py

@@ -35,7 +35,7 @@ def test_cli_analyze_generates_json_report(tmp_path):
     )
 
     assert proc.returncode == 0
-    report_file = output_dir / "full_report.json"
+    report_file = output_dir / "summary_report.json"
     assert report_file.exists()
     report = json.loads(report_file.read_text(encoding="utf-8"))
     assert "summary" in report

{codehealthanalyzer-1.2.2 → codehealthanalyzer-1.2.4}/tests/test_violations_analyzer.py

@@ -71,6 +71,18 @@ def test_check_file_python_syntax_error(tmp_path):
     assert len(result["violations"]) > 0
 
 
+def test_check_file_python_with_utf8_bom(tmp_path):
+    f = tmp_path / "bom_module.py"
+    f.write_text("x = 1\n", encoding="utf-8-sig")
+
+    result = _make(tmp_path, {"no_default_excludes": True}).check_file(f)
+
+    assert result["violations"] == []
+    assert result["priority"] == "low"
+    assert result["type"] == "Python"
+    assert result["lines"] == 1
+
+
 # ---------------------------------------------------------------------------
 # check_file — HTML
 # ---------------------------------------------------------------------------