code-ranker 3.0.0__tar.gz → 3.0.1__tar.gz

{code_ranker-3.0.0 → code_ranker-3.0.1}/Cargo.lock

@@ -268,7 +268,7 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
 [[package]]
 name = "code-ranker"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "anyhow",
  "chrono",
@@ -286,7 +286,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-graph"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "cel",
  "chrono",
@@ -298,7 +298,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugin-api"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "anyhow",
  "chrono",
@@ -309,7 +309,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-plugins"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "anyhow",
  "cargo_metadata",
@@ -336,7 +336,7 @@ dependencies = [
 
 [[package]]
 name = "code-ranker-viewer"
-version = "3.0.0"
+version = "3.0.1"
 dependencies = [
  "anyhow",
  "code-ranker-graph",

{code_ranker-3.0.0 → code_ranker-3.0.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "3"
 
 [workspace.package]
-version = "3.0.0"
+version = "3.0.1"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0"
@@ -12,10 +12,10 @@ keywords = ["dependency-graph", "coupling", "refactoring", "code-quality", "stat
 categories = ["development-tools", "command-line-utilities"]
 
 [workspace.dependencies]
-code-ranker-graph = { path = "crates/code-ranker-graph", version = "3.0.0" }
-code-ranker-plugin-api = { path = "crates/code-ranker-plugin-api", version = "3.0.0" }
-code-ranker-plugins = { path = "crates/code-ranker-plugins", version = "3.0.0" }
-code-ranker-viewer = { path = "crates/code-ranker-viewer", version = "3.0.0" }
+code-ranker-graph = { path = "crates/code-ranker-graph", version = "3.0.1" }
+code-ranker-plugin-api = { path = "crates/code-ranker-plugin-api", version = "3.0.1" }
+code-ranker-plugins = { path = "crates/code-ranker-plugins", version = "3.0.1" }
+code-ranker-viewer = { path = "crates/code-ranker-viewer", version = "3.0.1" }
 
 anyhow = "1.0"
 cel = "0.13"

{code_ranker-3.0.0 → code_ranker-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-ranker
-Version: 3.0.0
+Version: 3.0.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{code_ranker-3.0.0 → code_ranker-3.0.1}/crates/code-ranker-cli/build.rs

@@ -4,23 +4,39 @@
 //! `CORPUS: &[(rel_path, contents)]` slice built from `include_str!`, so the tool
 //! can serve a principle's Markdown (e.g. `--doc HK`) from the binary itself with
 //! no filesystem at runtime. Dependency-free (no `include_dir` crate).
+//!
+//! The corpus lives at the repo root (`../../languages`), OUTSIDE this crate, so it
+//! is NOT in the published crate tarball. A workspace build (the prebuilt binaries
+//! shipped via the installer / npm / PyPI / Docker / GitHub Release) finds it and
+//! embeds the full corpus; an ISOLATED build (`cargo publish` verify, or
+//! `cargo install code-ranker` from crates.io source) won't — so the corpus is
+//! resolved best-effort and absence yields an EMPTY corpus (never a build failure).
+//! `--doc` then reports "not embedded" on such builds; everything else works.
 
 use std::path::{Path, PathBuf};
 use std::{env, fs};
 
 fn main() {
     let manifest = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
-    let corpus = Path::new(&manifest)
-        .join("../../languages")
-        .canonicalize()
-        .expect("languages/ corpus directory exists");
-
-    // Re-run when the tree changes (added/removed files) and on any file edit.
-    println!("cargo:rerun-if-changed={}", corpus.display());
 
     let mut entries: Vec<(String, PathBuf)> = Vec::new();
-    collect(&corpus, &corpus, &mut entries);
-    entries.sort();
+    // Best-effort: a missing corpus (isolated/published build) is NOT an error —
+    // it must never break `cargo publish`/`cargo install`. See module docs.
+    match Path::new(&manifest).join("../../languages").canonicalize() {
+        Ok(corpus) => {
+            // Re-run when the tree changes (added/removed files) and on any file edit.
+            println!("cargo:rerun-if-changed={}", corpus.display());
+            collect(&corpus, &corpus, &mut entries);
+            entries.sort();
+        }
+        Err(_) => {
+            println!(
+                "cargo:warning=languages/ corpus not found (isolated build, e.g. \
+                 `cargo install code-ranker` from crates.io) — embedding an empty corpus; \
+                 `--doc` will report \"not embedded\". Prebuilt binaries embed the full corpus."
+            );
+        }
+    }
 
     let mut code = String::from(
         "/// Embedded doc corpus: (`<lang>/<ID>.md` relative path, file contents).\n\

{code_ranker-3.0.0 → code_ranker-3.0.1}/crates/code-ranker-cli/src/templates_test.rs

@@ -74,6 +74,37 @@ fn resolve_doc_assembles_a_language_manifest() {
     assert!(!doc.contains("<!-- doc:base"), "includes were expanded");
 }
 
+#[test]
+fn resolve_doc_manifest_uses_base_override_when_present() {
+    // A `templates.languages.base.<ID>` override substitutes the neutral base that
+    // a language manifest assembles over, so the custom base flows into the result.
+    let dir = tempfile::tempdir().unwrap();
+    let base_path = dir.path().join("base_adp.md");
+    let custom_base = corpus_doc("base/ADP.md")
+        .unwrap()
+        .replace("Acyclic", "ZZ-MARKER-ACYCLIC");
+    std::fs::write(&base_path, &custom_base).unwrap();
+    let mut templates = TemplatesConfig::default();
+    let mut base_overrides = BTreeMap::new();
+    base_overrides.insert("ADP".to_string(), base_path.to_string_lossy().into_owned());
+    templates
+        .languages
+        .insert("base".to_string(), base_overrides);
+
+    let s = snap(
+        vec![preset("ADP", "https://x/blob/main/languages/rust/ADP.md")],
+        BTreeMap::new(),
+    );
+    let doc = resolve_doc(&s, &templates, "ADP").unwrap();
+    let manifest = corpus_doc("rust/ADP.md").unwrap();
+    let expected = crate::compose::compose(manifest, &custom_base, "Rust").unwrap();
+    assert_eq!(doc, expected);
+    assert!(
+        doc.contains("ZZ-MARKER-ACYCLIC"),
+        "custom base flowed in: {doc}"
+    );
+}
+
 #[test]
 fn resolve_doc_override_wins_verbatim() {
     let dir = tempfile::tempdir().unwrap();

{code_ranker-3.0.0 → code_ranker-3.0.1}/crates/code-ranker-cli/tests/e2e.rs

@@ -460,6 +460,205 @@ fn rust_sample_check_baseline_verdict_neutral() {
     );
 }
 
+/// The self-baseline verdict also renders in the default human format as a
+/// trailing `Baseline verdict:` line (the json test above covers the wrapper).
+#[test]
+fn rust_sample_check_baseline_verdict_human() {
+    let root = repo_root();
+    let sample = sample_dir("rust");
+    let tmp = std::env::temp_dir().join("cs-e2e-baseline-rust-human.json");
+    let report = Command::new(env!("CARGO_BIN_EXE_code-ranker"))
+        .current_dir(&root)
+        .env("CARGO_NET_OFFLINE", "true")
+        .arg("report")
+        .arg(&sample)
+        .arg("--config")
+        .arg(sample.join("code-ranker.toml"))
+        .arg(format!("--output.json.path={}", tmp.display()))
+        .output()
+        .expect("spawn report");
+    assert!(report.status.success(), "baseline report");
+    let (_ok, stdout, _stderr) = run_check_capture("rust", &["--baseline", tmp.to_str().unwrap()]);
+    assert!(
+        stdout.contains("Baseline verdict: neutral"),
+        "human output carries the verdict line: {stdout}"
+    );
+}
+
+/// `check --focus-path` scopes the gate to a subtree: only violations under the
+/// path are reported and counted. The Rust sample's `chain` cycle lives in
+/// `src/chain/`, so focusing there keeps it and drops the `src/a.rs` mutual cycle.
+#[test]
+fn rust_sample_check_focus_path_scopes_gate() {
+    let (_ok, stdout, stderr) = run_check_capture("rust", &["--focus-path", "src/chain"]);
+    assert!(
+        stdout.contains("1 violation(s)") && stdout.contains("focused on path src/chain"),
+        "gate scoped to the focused subtree: {stdout}{stderr}"
+    );
+    assert!(
+        stdout.contains("src/chain/one.rs") && !stdout.contains("where  {target}/src/a.rs"),
+        "only the in-scope cycle is reported: {stdout}"
+    );
+}
+
+/// `check --focus-rule` scopes the gate to a rule id: focusing `cycle.mutual` keeps
+/// the `a ⇄ b` mutual cycle and drops the chain cycle.
+#[test]
+fn rust_sample_check_focus_rule_scopes_gate() {
+    let (_ok, stdout, stderr) = run_check_capture("rust", &["--focus-rule", "cycle.mutual"]);
+    assert!(
+        stdout.contains("1 violation(s)") && stdout.contains("focused on rule cycle.mutual"),
+        "gate scoped to the focused rule: {stdout}{stderr}"
+    );
+    assert!(
+        stdout.contains("src/a.rs"),
+        "the mutual-cycle member is reported: {stdout}"
+    );
+}
+
+/// `check --top N` limits how many violations are PRINTED (worst-first) without
+/// changing the exit code: the Rust sample's 2 cycles still fail the gate, but
+/// only the worst is shown plus a "showing the N worst" note.
+#[test]
+fn rust_sample_check_top_limits_reported_not_exit() {
+    let (ok, stdout, stderr) = run_check_capture("rust", &["--top", "1"]);
+    assert!(
+        !ok,
+        "gate still fails on the full violation count: {stderr}"
+    );
+    assert!(
+        stdout.contains("2 violation(s)") && stdout.contains("showing the 1 worst"),
+        "total counted, only the worst shown: {stdout}"
+    );
+    assert!(
+        stdout.contains("Summary (shown):"),
+        "summary marked as a partial view: {stdout}"
+    );
+}
+
+/// `report --prompt <metric>` composes the prompt through the metric lens (a
+/// synthesized metric "preset"), not a SOLID principle — exercising the metric
+/// arm of the standalone `--prompt` path.
+#[test]
+fn rust_sample_prompt_flag_targets_metric_lens() {
+    let (ok, stdout, stderr) = run_report_capture("rust", &["--prompt", "HK", "--top", "1"]);
+    assert!(ok, "--prompt HK run failed: {stderr}");
+    assert!(
+        stdout.contains("# HK") || stdout.contains("Henry"),
+        "metric-framed prompt, not a principle: {stdout}"
+    );
+}
+
+/// `--prompt` and `--doc` are mutually exclusive (the standalone-output guard).
+#[test]
+fn rust_sample_report_rejects_prompt_with_doc() {
+    let (ok, _stdout, stderr) = run_report_capture("rust", &["--prompt", "HK", "--doc", "SRP"]);
+    assert!(!ok, "mutually-exclusive flags must error");
+    assert!(
+        stderr.contains("--prompt and --doc are mutually exclusive"),
+        "names the conflict: {stderr}"
+    );
+}
+
+/// `docs --out <dir>` assembles the embedded corpus to disk: `base/*` verbatim and
+/// each language manifest as its composed Markdown. No analysis runs.
+#[test]
+fn docs_subcommand_writes_the_corpus() {
+    let root = repo_root();
+    let out = std::env::temp_dir().join("cs-e2e-docs-corpus");
+    let _ = std::fs::remove_dir_all(&out);
+    let res = Command::new(env!("CARGO_BIN_EXE_code-ranker"))
+        .current_dir(&root)
+        .arg("docs")
+        .arg("--out")
+        .arg(&out)
+        .output()
+        .expect("spawn docs");
+    assert!(res.status.success(), "docs run failed");
+    assert!(out.join("base/ADP.md").exists(), "base doc copied verbatim");
+    let assembled = std::fs::read_to_string(out.join("rust/ADP.md")).unwrap();
+    assert!(
+        !assembled.contains("<!-- doc:base"),
+        "manifest includes expanded on publish: {assembled}"
+    );
+}
+
+/// With no `--output.*` flag selected, `report` writes the default pair: a JSON
+/// snapshot and an HTML viewer (into `.code-ranker/` relative to the run dir).
+#[test]
+fn report_default_writes_json_and_html() {
+    let sample = sample_dir("rust");
+    let run_dir = std::env::temp_dir().join("cs-e2e-report-default");
+    let _ = std::fs::remove_dir_all(&run_dir);
+    std::fs::create_dir_all(&run_dir).unwrap();
+    let res = Command::new(env!("CARGO_BIN_EXE_code-ranker"))
+        .current_dir(&run_dir)
+        .env("CARGO_NET_OFFLINE", "true")
+        .arg("report")
+        .arg(&sample)
+        .arg("--config")
+        .arg(sample.join("code-ranker.toml"))
+        .output()
+        .expect("spawn report");
+    assert!(res.status.success(), "default report failed");
+    let written: Vec<String> = std::fs::read_dir(run_dir.join(".code-ranker"))
+        .expect(".code-ranker created")
+        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
+        .collect();
+    assert!(
+        written.iter().any(|f| f.ends_with(".json")),
+        "json snapshot written: {written:?}"
+    );
+    assert!(
+        written.iter().any(|f| f.ends_with(".html")),
+        "html viewer written: {written:?}"
+    );
+}
+
+/// A `--baseline` turns the HTML viewer into a diff and marks the filename
+/// `…-diff.html` (the rename branch of the html artifact path).
+#[test]
+fn report_baseline_html_is_named_diff() {
+    let root = repo_root();
+    let sample = sample_dir("rust");
+    let dir = std::env::temp_dir().join("cs-e2e-report-diff");
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let base = dir.join("base.json");
+    let html = dir.join("viewer.html");
+    // Capture a baseline snapshot.
+    let cap = Command::new(env!("CARGO_BIN_EXE_code-ranker"))
+        .current_dir(&root)
+        .env("CARGO_NET_OFFLINE", "true")
+        .arg("report")
+        .arg(&sample)
+        .arg("--config")
+        .arg(sample.join("code-ranker.toml"))
+        .arg(format!("--output.json.path={}", base.display()))
+        .output()
+        .expect("spawn baseline report");
+    assert!(cap.status.success(), "baseline capture failed");
+    // Render the HTML viewer against that baseline.
+    let res = Command::new(env!("CARGO_BIN_EXE_code-ranker"))
+        .current_dir(&root)
+        .env("CARGO_NET_OFFLINE", "true")
+        .arg("report")
+        .arg(&sample)
+        .arg("--config")
+        .arg(sample.join("code-ranker.toml"))
+        .arg("--baseline")
+        .arg(&base)
+        .arg(format!("--output.html.path={}", html.display()))
+        .output()
+        .expect("spawn diff report");
+    assert!(res.status.success(), "diff report failed");
+    assert!(
+        dir.join("viewer-diff.html").exists(),
+        "baseline run renames the html artifact to -diff.html"
+    );
+    assert!(!html.exists(), "the plain name is not used for a diff");
+}
+
 /// The `scorecard` format streams a per-principle table + worst-module list to
 /// stdout. The Rust sample has two cycles (the `a ⇄ b` mutual and the 3-node
 /// `chain`) and no metric breaches, so ADP is the only principle with violations

{code_ranker-3.0.0 → code_ranker-3.0.1}/crates/code-ranker-graph/src/builtin_test.rs

@@ -27,6 +27,34 @@ fn prompt_template_parses_from_markdown() {
     assert!(t.cycle_note.starts_with("This is **one** dependency cycle"));
 }
 
+/// `prompt_template_from` is the hook a `[templates] prompt = "…"` override flows
+/// through: it parses caller-supplied scaffolding instead of the built-in default.
+#[test]
+fn prompt_template_from_parses_caller_supplied_markdown() {
+    let md =
+        "## intro\nCustom intro line.\n\n## task\n- first\n- second\n\n## focus\nStay sharp.\n";
+    let t = prompt_template_from(md);
+    assert_eq!(t.intro, "Custom intro line.");
+    assert_eq!(t.task, vec!["- first", "- second"]);
+    assert_eq!(t.focus, "Stay sharp.");
+    // Unspecified sections stay at their default (empty).
+    assert!(t.cycle_note.is_empty());
+}
+
+/// `aggregate_formulas` exposes every `[report.stats]` formula; `stat_keys` is the
+/// subset whose formula is a plain mean — so the keys must be a subset of the map.
+#[test]
+fn aggregate_formulas_superset_of_stat_keys() {
+    let formulas = aggregate_formulas();
+    assert!(!formulas.is_empty(), "built-in report.stats is non-empty");
+    for k in stat_keys() {
+        assert!(
+            formulas.contains_key(&k),
+            "stat key {k:?} has a backing formula"
+        );
+    }
+}
+
 #[test]
 fn parses_and_compiles() {
     let (specs, groups) = metric_specs();