hecks 3.14.0 → 4.0.0

data/rust/build/src/resolve.rs

@@ -8,8 +8,12 @@ use crate::subprocess;
 
 pub fn bluebook_files(directory: &Path) -> Result<Vec<PathBuf>, String> {
     let mut files = Vec::new();
-    for entry in std::fs::read_dir(directory).map_err(|e| format!("reading {}: {e}", directory.display()))? {
-        let path = entry.map_err(|e| format!("reading {}: {e}", directory.display()))?.path();
+    for entry in
+        std::fs::read_dir(directory).map_err(|e| format!("reading {}: {e}", directory.display()))?
+    {
+        let path = entry
+            .map_err(|e| format!("reading {}: {e}", directory.display()))?
+            .path();
         if path.extension().and_then(|extension| extension.to_str()) == Some("bluebook") {
             files.push(path);
         }
@@ -20,7 +24,8 @@ pub fn bluebook_files(directory: &Path) -> Result<Vec<PathBuf>, String> {
 
 // Plain text scan of the `Hecks.bluebook "Name"` line; the file is never executed.
 pub fn header_chapter_name(path: &Path) -> Result<String, String> {
-    let text = std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+    let text =
+        std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
     for line in text.lines() {
         let trimmed = line.trim_start();
         if let Some(rest) = trimmed.strip_prefix("Hecks.bluebook") {
@@ -29,7 +34,10 @@ pub fn header_chapter_name(path: &Path) -> Result<String, String> {
             }
         }
     }
-    Err(format!("{} has no 'Hecks.bluebook \"Name\"' header", path.display()))
+    Err(format!(
+        "{} has no 'Hecks.bluebook \"Name\"' header",
+        path.display()
+    ))
 }
 
 fn extract_quoted(rest: &str) -> Option<String> {
@@ -52,25 +60,17 @@ pub fn framework_members(root: &Path) -> Result<Vec<(String, PathBuf)>, String>
         if path.extension().and_then(|e| e.to_str()) != Some("bluebook") {
             continue;
         }
-        let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("").to_string();
-        members.push((pascal(&stem), path));
+        let stem = path
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .unwrap_or("")
+            .to_string();
+        members.push((crate::hecks_naming::pascal(&stem), path));
     }
     members.sort();
     Ok(members)
 }
 
-pub fn pascal(text: &str) -> String {
-    text.split('_')
-        .map(|part| {
-            let mut chars = part.chars();
-            match chars.next() {
-                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
-                None => String::new(),
-            }
-        })
-        .collect()
-}
-
 // Discovery, not a mirrored filename list, so a new concept cannot drift from this pipeline.
 pub fn grammar_files(root: &Path) -> Result<Vec<PathBuf>, String> {
     let dir = root.join("lib/hecks/language/bluebook");
@@ -78,27 +78,50 @@ pub fn grammar_files(root: &Path) -> Result<Vec<PathBuf>, String> {
 }
 
 // The names `attaches "Name"` gave, for a chapter the gem carries.
-pub fn resolve_gem_chapters(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
+pub fn resolve_gem_chapters(
+    parser_bin: &Path,
+    chapter_name: &str,
+    hecksagon_path: &Path,
+) -> Result<Vec<String>, String> {
     resolve_json(parser_bin, chapter_name, hecksagon_path, "gem_chapters")
 }
 
 // The names `attaches "name", from: :vendor` gave, for a vendored package.
-pub fn resolve_vendored_packages(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
-    resolve_json(parser_bin, chapter_name, hecksagon_path, "vendored_packages")
+pub fn resolve_vendored_packages(
+    parser_bin: &Path,
+    chapter_name: &str,
+    hecksagon_path: &Path,
+) -> Result<Vec<String>, String> {
+    resolve_json(
+        parser_bin,
+        chapter_name,
+        hecksagon_path,
+        "vendored_packages",
+    )
 }
 
 // Where the gem keeps the chapters other than framework members, relative to `lib/hecks`; the
 // same places `Hecks::Chapters::GLOBS` lists.
-const OTHER_GEM_CHAPTER_DIRS: &[&str] = &["language", "grammar", "tenancy/bluebook", "deploy/bluebook", "quality_control"];
+const OTHER_GEM_CHAPTER_DIRS: &[&str] = &[
+    "language",
+    "grammar",
+    "tenancy/bluebook",
+    "deploy/bluebook",
+    "quality_control",
+];
 
 // The names of the chapters the gem carries beside the framework members, found by reading each
 // file's header. Only the Ruby runtime loads them, so the build uses this list to tell a real
 // gem chapter from a misspelt name.
 pub fn other_gem_chapter_names(root: &Path) -> Result<Vec<String>, String> {
     fn walk(directory: &Path, names: &mut Vec<String>) -> Result<(), String> {
-        let Ok(entries) = std::fs::read_dir(directory) else { return Ok(()) };
+        let Ok(entries) = std::fs::read_dir(directory) else {
+            return Ok(());
+        };
         for entry in entries {
-            let path = entry.map_err(|e| format!("reading {}: {e}", directory.display()))?.path();
+            let path = entry
+                .map_err(|e| format!("reading {}: {e}", directory.display()))?
+                .path();
             if path.is_dir() {
                 walk(&path, names)?;
             } else if path.extension().and_then(|e| e.to_str()) == Some("bluebook") {
@@ -118,13 +141,26 @@ pub fn other_gem_chapter_names(root: &Path) -> Result<Vec<String>, String> {
     Ok(names)
 }
 
-fn resolve_json(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path, key: &str) -> Result<Vec<String>, String> {
+fn resolve_json(
+    parser_bin: &Path,
+    chapter_name: &str,
+    hecksagon_path: &Path,
+    key: &str,
+) -> Result<Vec<String>, String> {
     let parser_bin_str = parser_bin.to_string_lossy().to_string();
     let hecksagon_str = hecksagon_path.to_string_lossy().to_string();
-    let out = subprocess::run_capture(&parser_bin_str, &["resolve", "--chapter", chapter_name, &hecksagon_str])?;
-    let json = Json::parse(&out).map_err(|e| format!("parsing 'hecks-parse resolve' output: {e}\n{out}"))?;
-    let names = json.get(key).map(Json::each).unwrap_or(&[]);
-    Ok(names.iter().filter_map(Json::as_str).map(str::to_string).collect())
+    let out = subprocess::run_capture(
+        &parser_bin_str,
+        &["resolve", "--chapter", chapter_name, &hecksagon_str],
+    )?;
+    let json = Json::parse(&out)
+        .map_err(|e| format!("parsing 'hecks-parse resolve' output: {e}\n{out}"))?;
+    let names = json.get(key).map_or(&[][..], Json::each);
+    Ok(names
+        .iter()
+        .filter_map(Json::as_str)
+        .map(str::to_string)
+        .collect())
 }
 
 /// `/\A[a-z][a-z0-9_]*\z/` — the shape `hecks vendor` accepts for a package directory name.
@@ -132,7 +168,8 @@ fn resolve_json(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path, ke
 /// so `../x` or an absolute path must never reach either.
 pub fn valid_package_name(name: &str) -> bool {
     let mut chars = name.chars();
-    matches!(chars.next(), Some(c) if c.is_ascii_lowercase()) && chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
+    matches!(chars.next(), Some(c) if c.is_ascii_lowercase())
+        && chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
 }
 
 pub fn vendored_bluebook_files(domain: &Path, pkg_name: &str) -> Result<Vec<PathBuf>, String> {
@@ -141,7 +178,11 @@ pub fn vendored_bluebook_files(domain: &Path, pkg_name: &str) -> Result<Vec<Path
             "attaches {pkg_name:?}, from: :vendor is not a package name — it must match [a-z][a-z0-9_]* (the name `hecks vendor` accepts)"
         ));
     }
-    let dir = domain.join("vendor").join("embryonaut_bluebooks").join(pkg_name).join("bluebook");
+    let dir = domain
+        .join("vendor")
+        .join("embryonaut_bluebooks")
+        .join(pkg_name)
+        .join("bluebook");
     if !dir.is_dir() {
         return Err(format!(
             "attaches {pkg_name:?}, from: :vendor names no vendored bluebook at {} — run hecks vendor {pkg_name}",
@@ -169,14 +210,20 @@ mod tests {
 
     #[test]
     fn pascal_cases_snake_case_stems() {
-        assert_eq!(pascal("governance"), "Governance");
-        assert_eq!(pascal("console_settings"), "ConsoleSettings");
-        assert_eq!(pascal("identity"), "Identity");
+        assert_eq!(crate::hecks_naming::pascal("governance"), "Governance");
+        assert_eq!(
+            crate::hecks_naming::pascal("console_settings"),
+            "ConsoleSettings"
+        );
+        assert_eq!(crate::hecks_naming::pascal("identity"), "Identity");
     }
 
     #[test]
     fn extracts_the_quoted_chapter_name() {
         assert_eq!(extract_quoted(r#" "Pizzas""#), Some("Pizzas".to_string()));
-        assert_eq!(extract_quoted(r#" "Console Settings" do"#), Some("Console Settings".to_string()));
+        assert_eq!(
+            extract_quoted(r#" "Console Settings" do"#),
+            Some("Console Settings".to_string())
+        );
     }
 }

data/rust/build/src/rustfmt.rs

@@ -0,0 +1,100 @@
+//! Lays generated Rust out with rustfmt, as `Hecks::RustFormat` does for `hecks project_rust`, so
+//! the tree `hecks-build` writes matches the one `hecks project_rust` writes, byte for byte.
+
+use std::io::Write as _;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+
+const EDITION: &str = "2021";
+
+// The most passes made; a text still changing after them keeps the last result, as in Ruby.
+const PASSES: usize = 3;
+
+/// Formats every `.rs` file of this run's own output: the `mod.rs` at `out_root` and each of
+/// `dirs` beneath it, skipping a directory that is not there. A file is rewritten only when its
+/// layout changes, so mtimes stay put and Cargo does not rebuild what did not change.
+pub fn format_generated(out_root: &Path, dirs: &[String]) -> Result<(), String> {
+    let mut files = vec![out_root.join("mod.rs")];
+    for dir in dirs {
+        collect_rust_files(&out_root.join(dir), &mut files)?;
+    }
+    for file in files.iter().filter(|f| f.is_file()) {
+        format_file(file)?;
+    }
+    Ok(())
+}
+
+fn collect_rust_files(dir: &Path, into: &mut Vec<PathBuf>) -> Result<(), String> {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return Ok(());
+    };
+    let mut paths: Vec<PathBuf> = entries.filter_map(|e| e.ok().map(|e| e.path())).collect();
+    paths.sort();
+    for path in paths {
+        if path.is_dir() {
+            collect_rust_files(&path, into)?;
+        } else if path.extension().is_some_and(|ext| ext == "rs") {
+            into.push(path);
+        }
+    }
+    Ok(())
+}
+
+fn format_file(path: &Path) -> Result<(), String> {
+    let text =
+        std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+    let formatted = format_source(&text)?;
+    if formatted != text {
+        std::fs::write(path, formatted).map_err(|e| format!("writing {}: {e}", path.display()))?;
+    }
+    Ok(())
+}
+
+fn format_source(text: &str) -> Result<String, String> {
+    let mut current = text.to_string();
+    for _ in 0..PASSES {
+        let formatted = pass(&current)?;
+        if formatted == current {
+            break;
+        }
+        current = formatted;
+    }
+    Ok(current)
+}
+
+// One rustfmt run over stdin. Text rustfmt cannot parse is returned as it came, with a warning:
+// the compiler will name the real fault. Any other failure of rustfmt is an error.
+fn pass(text: &str) -> Result<String, String> {
+    let mut child = Command::new("rustfmt")
+        .args(["--edition", EDITION, "--emit", "stdout"])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| {
+            format!("running rustfmt: {e} (generated Rust is formatted with it; run `rustup component add rustfmt`)")
+        })?;
+    let mut stdin = child.stdin.take().ok_or("rustfmt gave no stdin")?;
+    let input = text.to_string();
+    // Written from a thread: a large file fills the pipe before rustfmt starts reading its output.
+    let writer = std::thread::spawn(move || stdin.write_all(input.as_bytes()));
+    let output = child
+        .wait_with_output()
+        .map_err(|e| format!("waiting for rustfmt: {e}"))?;
+    let _ = writer.join();
+    if output.status.success() {
+        return String::from_utf8(output.stdout)
+            .map_err(|e| format!("rustfmt output was not UTF-8: {e}"));
+    }
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let first = stderr.lines().next().unwrap_or_default().to_string();
+    // A parse error names `<stdin>`; anything else is rustfmt itself failing, and falling back to
+    // the unformatted text would write the wrong bytes without a word.
+    if !stderr.contains("<stdin>") {
+        return Err(format!("rustfmt failed: {first}"));
+    }
+    eprintln!(
+        "hecks-build: rustfmt could not format generated Rust, leaving it as generated: {first}"
+    );
+    Ok(text.to_string())
+}

data/rust/build/src/seams_pass.rs

@@ -16,9 +16,27 @@ struct Seam {
 
 // In `TargetIr::SEAMS` order, which is the order the keys land in `ir.json`.
 const SEAMS: &[Seam] = &[
-    Seam { capability: "authorization", export_as: "authorization", verbs: &["grant", "assignments"], aggregates: &[("assignment_aggregate", "assignments")], marks: &[] },
-    Seam { capability: "membership", export_as: "membership", verbs: &["admit", "grant", "people"], aggregates: &[("aggregate", "admit")], marks: &[] },
-    Seam { capability: "identity", export_as: "identity", verbs: &["register", "link", "resolve"], aggregates: &[], marks: &[] },
+    Seam {
+        capability: "authorization",
+        export_as: "authorization",
+        verbs: &["grant", "assignments"],
+        aggregates: &[("assignment_aggregate", "assignments")],
+        marks: &[],
+    },
+    Seam {
+        capability: "membership",
+        export_as: "membership",
+        verbs: &["admit", "grant", "people"],
+        aggregates: &[("aggregate", "admit")],
+        marks: &[],
+    },
+    Seam {
+        capability: "identity",
+        export_as: "identity",
+        verbs: &["register", "link", "resolve"],
+        aggregates: &[],
+        marks: &[],
+    },
     Seam {
         capability: "newsletter",
         export_as: "newsletter",
@@ -30,21 +48,41 @@ const SEAMS: &[Seam] = &[
         capability: "newsletter_issues",
         export_as: "newsletter_issues",
         verbs: &["send_issue", "record_delivery"],
-        aggregates: &[("issue_aggregate", "send_issue"), ("delivery_aggregate", "record_delivery")],
+        aggregates: &[
+            ("issue_aggregate", "send_issue"),
+            ("delivery_aggregate", "record_delivery"),
+        ],
         marks: &[],
     },
-    Seam { capability: "payments", export_as: "payments", verbs: &["initiate", "succeeded", "failed"], aggregates: &[("aggregate", "initiate")], marks: &["holds_seat"] },
+    Seam {
+        capability: "payments",
+        export_as: "payments",
+        verbs: &["initiate", "succeeded", "failed"],
+        aggregates: &[("aggregate", "initiate")],
+        marks: &["holds_seat"],
+    },
     Seam {
         capability: "registrations",
         export_as: "registrations",
         verbs: &["schedule", "request"],
-        aggregates: &[("event_aggregate", "schedule"), ("registration_aggregate", "request")],
+        aggregates: &[
+            ("event_aggregate", "schedule"),
+            ("registration_aggregate", "request"),
+        ],
         marks: &["frees_seat"],
     },
     Seam {
         capability: "payment_connection",
         export_as: "payment_connection",
-        verbs: &["connect", "reconnect", "disconnect", "suspend", "resume", "enable", "disable"],
+        verbs: &[
+            "connect",
+            "reconnect",
+            "disconnect",
+            "suspend",
+            "resume",
+            "enable",
+            "disable",
+        ],
         aggregates: &[("aggregate", "connect")],
         marks: &[],
     },
@@ -60,7 +98,12 @@ pub fn run(target: &mut Json, members: &[Json]) -> Result<(), String> {
     let mut membership = false;
     let mut identity = false;
     for seam in SEAMS {
-        let Some(provider) = chapters.iter().find(|chapter| provision(chapter, seam.capability).is_some()) else { continue };
+        let Some(provider) = chapters
+            .iter()
+            .find(|chapter| provision(chapter, seam.capability).is_some())
+        else {
+            continue;
+        };
         let exported = export(seam, provider);
         membership |= seam.capability == "membership";
         identity |= seam.capability == "identity";
@@ -79,7 +122,12 @@ pub fn run(target: &mut Json, members: &[Json]) -> Result<(), String> {
 fn export(seam: &Seam, provider: &Json) -> Json {
     let name = name_of(provider);
     let entries = provision(provider, seam.capability).unwrap_or_default();
-    let verb = |key: &str| entries.iter().find(|(k, _)| k == key).map(|(_, v)| format!("{name}::{v}"));
+    let verb = |key: &str| {
+        entries
+            .iter()
+            .find(|(k, _)| k == key)
+            .map(|(_, v)| format!("{name}::{v}"))
+    };
 
     let mut out = vec![("provider".to_string(), Json::String(name.clone()))];
     for key in seam.verbs {
@@ -87,10 +135,19 @@ fn export(seam: &Seam, provider: &Json) -> Json {
     }
     for (exported, key) in seam.aggregates {
         let aggregate = verb(key).map(|v| v.split('.').next().unwrap_or_default().to_string());
-        out.push((exported.to_string(), aggregate.map_or(Json::Null, Json::String)));
+        out.push((
+            exported.to_string(),
+            aggregate.map_or(Json::Null, Json::String),
+        ));
     }
     for key in seam.marks {
-        if let Some(states) = marked_states(provider, entries.iter().find(|(k, _)| k == key).map(|(_, v)| v.as_str())) {
+        if let Some(states) = marked_states(
+            provider,
+            entries
+                .iter()
+                .find(|(k, _)| k == key)
+                .map(|(_, v)| v.as_str()),
+        ) {
             out.push((key.to_string(), states));
         }
     }
@@ -101,11 +158,15 @@ fn export(seam: &Seam, provider: &Json) -> Json {
 fn provision(chapter: &Json, capability: &str) -> Option<Vec<(String, String)>> {
     let entries: Vec<(String, String)> = chapter
         .get("provides")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or(&[][..], Json::each)
         .iter()
         .filter(|entry| entry.get("capability").and_then(Json::as_str) == Some(capability))
-        .filter_map(|entry| Some((entry.get("key")?.as_str()?.to_string(), entry.get("verb")?.as_str()?.to_string())))
+        .filter_map(|entry| {
+            Some((
+                entry.get("key")?.as_str()?.to_string(),
+                entry.get("verb")?.as_str()?.to_string(),
+            ))
+        })
         .collect();
     (!entries.is_empty()).then_some(entries)
 }
@@ -114,10 +175,18 @@ fn provision(chapter: &Json, capability: &str) -> Option<Vec<(String, String)>>
 // entry is not declared or the mark is.
 fn marked_states(provider: &Json, entry: Option<&str>) -> Option<Json> {
     let (aggregate_name, mark) = entry?.split_once('.')?;
-    let aggregate = provider.get("aggregates").map(Json::each)?.iter().find(|a| a.get("name").and_then(Json::as_str) == Some(aggregate_name))?;
+    let aggregate = provider
+        .get("aggregates")
+        .map(Json::each)?
+        .iter()
+        .find(|a| a.get("name").and_then(Json::as_str) == Some(aggregate_name))?;
     aggregate.get("lifecycle")?.get("marks")?.get(mark).cloned()
 }
 
 fn name_of(chapter: &Json) -> String {
-    chapter.get("name").and_then(Json::as_str).unwrap_or_default().to_string()
+    chapter
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or_default()
+        .to_string()
 }

data/rust/build/src/subprocess.rs

@@ -5,7 +5,10 @@ use std::path::Path;
 use std::process::{Command, Stdio};
 
 pub fn run_capture(program: &str, args: &[&str]) -> Result<String, String> {
-    let output = Command::new(program).args(args).output().map_err(|e| format!("running {program} {}: {e}", args.join(" ")))?;
+    let output = Command::new(program)
+        .args(args)
+        .output()
+        .map_err(|e| format!("running {program} {}: {e}", args.join(" ")))?;
     if !output.status.success() {
         return Err(format!(
             "{program} {} failed:\n{}",
@@ -13,11 +16,19 @@ pub fn run_capture(program: &str, args: &[&str]) -> Result<String, String> {
             String::from_utf8_lossy(&output.stderr)
         ));
     }
-    String::from_utf8(output.stdout).map_err(|e| format!("{program} {}: stdout was not valid UTF-8: {e}", args.join(" ")))
+    String::from_utf8(output.stdout).map_err(|e| {
+        format!(
+            "{program} {}: stdout was not valid UTF-8: {e}",
+            args.join(" ")
+        )
+    })
 }
 
 pub fn run(program: &str, args: &[&str]) -> Result<(), String> {
-    let status = Command::new(program).args(args).status().map_err(|e| format!("running {program} {}: {e}", args.join(" ")))?;
+    let status = Command::new(program)
+        .args(args)
+        .status()
+        .map_err(|e| format!("running {program} {}: {e}", args.join(" ")))?;
     if !status.success() {
         return Err(format!("{program} {} failed", args.join(" ")));
     }
@@ -29,9 +40,19 @@ pub fn run_in(dir: &Path, program: &str, args: &[&str]) -> Result<(), String> {
         .args(args)
         .current_dir(dir)
         .status()
-        .map_err(|e| format!("running {program} {} in {}: {e}", args.join(" "), dir.display()))?;
+        .map_err(|e| {
+            format!(
+                "running {program} {} in {}: {e}",
+                args.join(" "),
+                dir.display()
+            )
+        })?;
     if !status.success() {
-        return Err(format!("{program} {} failed in {}", args.join(" "), dir.display()));
+        return Err(format!(
+            "{program} {} failed in {}",
+            args.join(" "),
+            dir.display()
+        ));
     }
     Ok(())
 }
@@ -45,7 +66,10 @@ pub fn cargo_build_quiet(dir: &Path) -> Result<(), String> {
         .status()
         .map_err(|e| format!("running cargo build in {}: {e}", dir.display()))?;
     if !status.success() {
-        return Err(format!("cargo build failed in {} — run it there directly to see why", dir.display()));
+        return Err(format!(
+            "cargo build failed in {} — run it there directly to see why",
+            dir.display()
+        ));
     }
     Ok(())
 }

data/rust/build/src/tmp.rs

@@ -13,9 +13,12 @@ impl TempDir {
     pub fn new(prefix: &str) -> Result<Self, String> {
         let base = std::env::temp_dir();
         let pid = std::process::id();
-        let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0);
+        let nanos = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_or(0, |d| d.as_nanos());
         let path = base.join(format!("{prefix}-{pid}-{nanos}"));
-        std::fs::create_dir_all(&path).map_err(|e| format!("creating temp dir {}: {e}", path.display()))?;
+        std::fs::create_dir_all(&path)
+            .map_err(|e| format!("creating temp dir {}: {e}", path.display()))?;
         Ok(Self { path })
     }