hecks 2.8.0 → 3.0.0

data/rust/build/src/cargo_sync.rs

@@ -0,0 +1,248 @@
+//! Rewrites the root `generated/mod.rs` and syncs `rust/Cargo.toml` `[features]`.
+//! Ports `sync_mod_and_cargo!`, keeping its output byte-identical.
+
+use std::path::Path;
+
+// Both tables come from the reserved-word vocabularies via `hecks project_reserved_names`.
+use crate::reserved_names::{CARGO_RESERVED_DOMAIN_NAMES, RUST_KEYWORDS};
+
+/// True if `name` works as a directory, a bare Rust module identifier and a Cargo feature key.
+pub fn valid_domain_mod_name(name: &str) -> bool {
+    let mut chars = name.chars();
+    let starts_ok = matches!(chars.next(), Some(c) if c == '_' || c.is_ascii_lowercase());
+    let rest_ok = chars.all(|c| c == '_' || c.is_ascii_lowercase() || c.is_ascii_digit());
+    starts_ok && rest_ok && !RUST_KEYWORDS.contains(&name) && !CARGO_RESERVED_DOMAIN_NAMES.contains(&name)
+}
+
+/// Lists the directories under `out_root`, and those with a `merged.rs` (activatable domains).
+fn scan_generated_dirs(out_root: &Path) -> Result<(Vec<String>, Vec<String>), String> {
+    let mut all_dirs = Vec::new();
+    for entry in std::fs::read_dir(out_root).map_err(|e| format!("reading {}: {e}", out_root.display()))? {
+        let entry = entry.map_err(|e| format!("reading {}: {e}", out_root.display()))?;
+        if entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
+            all_dirs.push(entry.file_name().to_string_lossy().to_string());
+        }
+    }
+    all_dirs.sort();
+
+    let domains = all_dirs.iter().filter(|name| out_root.join(name).join("merged.rs").is_file()).cloned().collect();
+
+    Ok((all_dirs, domains))
+}
+
+/// Rewrites the root `mod.rs`: a `pub mod` per directory and an `active` re-export per domain.
+///
+/// Cargo has no mutually-exclusive features, so the default domain's re-export backs off when
+/// another domain feature is on, and two non-default features hit an explicit `compile_error!`
+/// instead of a duplicate-import E0252.
+fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], target_mod_name: &str) -> Result<(), String> {
+    let mut out = String::new();
+    out.push_str("// GENERATED by hecks project_rust — re-run it to refresh this list.\n");
+    out.push_str("//\n");
+    out.push_str("// BUG#25 — every DOMAIN (an entry in `domains`, below: a directory\n");
+    out.push_str("// carrying its own merged.rs and therefore its own Cargo feature) is\n");
+    out.push_str("// declared behind that SAME feature, so a broken or absent domain's\n");
+    out.push_str("// generated code is never even compiled into a build that selects a\n");
+    out.push_str("// DIFFERENT domain — `cargo build --features waybill` used to pull in\n");
+    out.push_str("// every OTHER domain's `pub mod` unconditionally, so one domain's own\n");
+    out.push_str("// non-compiling generated code (a `has_many` field, before this fix)\n");
+    out.push_str("// broke every feature's build, not just its own. A shared FRAMEWORK\n");
+    out.push_str("// chapter (governance/identity — no merged.rs of its own, so absent\n");
+    out.push_str("// from `domains`) stays unconditional: it has no single feature of its\n");
+    out.push_str("// own to gate behind, and is compiled in by whichever domain(s) attach\n");
+    out.push_str("// it via `uses_framework`.\n");
+    for name in all_dirs {
+        if domains.iter().any(|d| d == name) {
+            out.push_str(&format!("#[cfg(feature = {name:?})]\n"));
+        }
+        out.push_str(&format!("pub mod {name};\n"));
+    }
+    out.push('\n');
+    out.push_str("// `active` is whichever ONE domain's own merged Store/dispatch table\n");
+    out.push_str("// is selected by Cargo feature (rust/Cargo.toml, kept in sync with this\n");
+    out.push_str("// list by hecks project_rust) — kernel/cli.rs imports\n");
+    out.push_str("// `crate::generated::active::{dispatch_by_name, Store, ...}` unchanged\n");
+    out.push_str("// no matter which domain that resolves to.\n");
+    out.push_str("//\n");
+    out.push_str("// DOMAIN FEATURES ARE MUTUALLY EXCLUSIVE (R5) — Cargo has no native\n");
+    out.push_str(&format!("// concept of that, and `default = [{target_mod_name:?}]` in\n"));
+    out.push_str("// Cargo.toml stays enabled unless a build passes\n");
+    out.push_str("// `--no-default-features`, so a plain `cargo build --features banking`\n");
+    out.push_str("// used to enable BOTH the default domain's feature and banking's,\n");
+    out.push_str("// producing two `pub use ... as active;` imports and a hard E0252.\n");
+    out.push_str("// Fixed two ways below, entirely mechanically from `domains`/\n");
+    out.push_str("// `target_mod_name` (this run's new default) — never hand-maintained:\n");
+    out.push_str("//\n");
+    out.push_str("//   1. THE DEFAULT DOMAIN'S OWN re-export backs off whenever any OTHER\n");
+    out.push_str("//      domain feature is also enabled, so it never contends for `active`\n");
+    out.push_str("//      by accident — `cargo build --features banking` (still implicitly\n");
+    out.push_str("//      carrying the default feature) now resolves to banking alone,\n");
+    out.push_str("//      same as if `--no-default-features` had been passed explicitly.\n");
+    out.push_str("//   2. Two NON-default domain features enabled TOGETHER (a genuine,\n");
+    out.push_str("//      not-accidental conflict — nothing makes that combination\n");
+    out.push_str("//      meaningful) still fail the build, but with an explicit\n");
+    out.push_str("//      `compile_error!` naming both features instead of a cryptic\n");
+    out.push_str("//      \"defined multiple times\".\n");
+    for name in domains {
+        let other_domains: Vec<&String> = domains.iter().filter(|n| n.as_str() != name.as_str()).collect();
+        if name.as_str() == target_mod_name && !other_domains.is_empty() {
+            let guard = other_domains.iter().map(|o| format!("feature = {o:?}")).collect::<Vec<_>>().join(", ");
+            out.push_str(&format!("#[cfg(all(feature = {name:?}, not(any({guard}))))]\n"));
+        } else {
+            out.push_str(&format!("#[cfg(feature = {name:?})]\n"));
+        }
+        out.push_str(&format!("pub use {name}::merged as active;\n"));
+    }
+
+    let non_default_domains: Vec<&String> = domains.iter().filter(|n| n.as_str() != target_mod_name).collect();
+    if non_default_domains.len() > 1 {
+        out.push('\n');
+        out.push_str("// Explicit conflict guard — see point 2 above. Only fires when TWO\n");
+        out.push_str("// non-default domain features are both turned on; the default\n");
+        out.push_str("// domain's own feature never reaches here (point 1 already excludes\n");
+        out.push_str("// it whenever any other domain feature is present).\n");
+        let domains_joined = domains.join(", ");
+        for i in 0..non_default_domains.len() {
+            for j in (i + 1)..non_default_domains.len() {
+                let a = non_default_domains[i];
+                let b = non_default_domains[j];
+                out.push_str(&format!("#[cfg(all(feature = {a:?}, feature = {b:?}))]\n"));
+                out.push_str(&format!(
+                    "compile_error!(\"domain features are mutually exclusive — enable only one of: {domains_joined} (both {a} and {b} are enabled)\");\n"
+                ));
+            }
+        }
+    }
+
+    let path = out_root.join("mod.rs");
+    std::fs::write(&path, out).map_err(|e| format!("writing {}: {e}", path.display()))?;
+    println!("wrote {}", path.display());
+    Ok(())
+}
+
+/// The `[features]` table text, from its header to the next `[section]` header or EOF.
+/// Empty if there is no `[features]` header.
+fn features_table_slice(text: &str) -> &str {
+    let Some(start) = text.find("[features]") else { return "" };
+    let rest = &text[start..];
+    let mut pos = 0;
+    for (i, line) in rest.split_inclusive('\n').enumerate() {
+        if i > 0 && line.trim_start().starts_with('[') {
+            return &rest[..pos];
+        }
+        pos += line.len();
+    }
+    rest
+}
+
+fn sync_cargo_toml_features(cargo_toml_path: &Path, domains: &[String], target_mod_name: &str) -> Result<(), String> {
+    let mut cargo_toml = std::fs::read_to_string(cargo_toml_path).map_err(|e| format!("reading {}: {e}", cargo_toml_path.display()))?;
+
+    if !cargo_toml.contains("[features]") {
+        let preamble = "# ONE FEATURE PER GENERATED DOMAIN — selects which domain's own\n\
+             # generated::<domain>::merged module `generated::active` re-exports\n\
+             # (rust/src/generated/mod.rs). Kept in sync by hecks project_rust: a\n\
+             # feature is added here whenever a new domain is generated, never\n\
+             # removed (the domain's own generated/<name>/ directory is the\n\
+             # source of truth for whether it still exists). `default` tracks\n\
+             # whichever domain was generated MOST RECENTLY, so a bare\n\
+             # `cargo build`/`cargo test` keeps behaving exactly as it always\n\
+             # has; any other still-generated domain stays reachable via\n\
+             # `--no-default-features --features <name>`.\n\
+             [features]\n\
+             default = []\n\n";
+        cargo_toml = format!("{preamble}{cargo_toml}");
+    }
+
+    // Scoped to `[features]`: matching `name = ` file-wide hits `[package]` keys like `version`.
+    for name in domains {
+        let already_declared = features_table_slice(&cargo_toml).lines().any(|line| {
+            line.trim_start().strip_prefix(name.as_str()).map(|rest| rest.trim_start().starts_with('=')).unwrap_or(false)
+        });
+        if already_declared {
+            continue;
+        }
+        cargo_toml = insert_after_default(&cargo_toml, &format!("{name} = []"));
+    }
+
+    cargo_toml = replace_default_line(&cargo_toml, &format!("default = [{:?}]", target_mod_name));
+
+    std::fs::write(cargo_toml_path, &cargo_toml).map_err(|e| format!("writing {}: {e}", cargo_toml_path.display()))?;
+    println!("wrote {} (default feature: {target_mod_name})", cargo_toml_path.display());
+    Ok(())
+}
+
+fn find_default_line_span(text: &str) -> Option<(usize, usize)> {
+    let mut pos = 0;
+    for line in text.split_inclusive('\n') {
+        let content = line.strip_suffix('\n').unwrap_or(line);
+        if is_default_line(content) {
+            return Some((pos, pos + content.len()));
+        }
+        pos += line.len();
+    }
+    None
+}
+
+// Always re-finds the original `default` line, so features added in one run land in reverse
+// order, matching the Ruby pipeline byte-for-byte.
+fn insert_after_default(text: &str, new_line: &str) -> String {
+    match find_default_line_span(text) {
+        Some((_start, end)) => {
+            let mut out = String::with_capacity(text.len() + new_line.len() + 1);
+            out.push_str(&text[..end]);
+            out.push('\n');
+            out.push_str(new_line);
+            out.push_str(&text[end..]);
+            out
+        }
+        None => text.to_string(),
+    }
+}
+
+fn replace_default_line(text: &str, new_line: &str) -> String {
+    match find_default_line_span(text) {
+        Some((start, end)) => format!("{}{}{}", &text[..start], new_line, &text[end..]),
+        None => text.to_string(),
+    }
+}
+
+fn is_default_line(line_content: &str) -> bool {
+    let trimmed = line_content.trim_start();
+    trimmed.strip_prefix("default").map(|rest| rest.trim_start().starts_with('=')).unwrap_or(false)
+}
+
+/// Rewrites the root `mod.rs` and syncs `rust/Cargo.toml`'s `[features]` for the domains on disk.
+pub fn run(out_root: &Path, cargo_toml_path: &Path, target_mod_name: &str) -> Result<(), String> {
+    let (all_dirs, domains) = scan_generated_dirs(out_root)?;
+    write_root_mod(out_root, &all_dirs, &domains, target_mod_name)?;
+    sync_cargo_toml_features(cargo_toml_path, &domains, target_mod_name)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn inserts_after_the_default_line() {
+        let text = "[features]\ndefault = []\n\n";
+        let result = insert_after_default(text, "pizzas = []");
+        assert_eq!(result, "[features]\ndefault = []\npizzas = []\n\n");
+    }
+
+    #[test]
+    fn later_insertions_land_before_earlier_ones_matching_rubys_quirk() {
+        let text = "[features]\ndefault = []\n";
+        let after_a = insert_after_default(text, "a = []");
+        let after_b = insert_after_default(&after_a, "b = []");
+        assert_eq!(after_b, "[features]\ndefault = []\nb = []\na = []\n");
+    }
+
+    #[test]
+    fn replaces_the_default_line_content() {
+        let text = "[features]\ndefault = []\npizzas = []\n";
+        let result = replace_default_line(text, "default = [\"banking\"]");
+        assert_eq!(result, "[features]\ndefault = [\"banking\"]\npizzas = []\n");
+    }
+}

data/rust/build/src/json.rs

@@ -0,0 +1,421 @@
+//! A minimal, dependency-free, mutable JSON value with a reader and a pretty writer.
+//! The writer matches `JSON.pretty_generate` byte-for-byte, including its empty-array quirk.
+
+use std::fmt::Write as _;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Json {
+    Null,
+    Bool(bool),
+    /// Raw literal text as scanned, so numbers round-trip unchanged.
+    Number(String),
+    String(String),
+    Array(Vec<Json>),
+    /// Insertion-ordered pairs; byte-exact re-emission depends on key order.
+    Object(Vec<(String, Json)>),
+}
+
+impl Json {
+    pub fn parse(text: &str) -> Result<Json, String> {
+        let mut p = Parser { bytes: text.as_bytes(), pos: 0 };
+        p.skip_ws();
+        let value = p.parse_value()?;
+        p.skip_ws();
+        if p.pos != p.bytes.len() {
+            return Err(format!("trailing content at byte {}", p.pos));
+        }
+        Ok(value)
+    }
+
+    /// Looks up `key`, treating a `null` value as missing.
+    pub fn get(&self, key: &str) -> Option<&Json> {
+        match self {
+            Json::Object(pairs) => pairs.iter().find(|(k, v)| k == key && !matches!(v, Json::Null)).map(|(_, v)| v),
+            _ => None,
+        }
+    }
+
+    pub fn get_mut(&mut self, key: &str) -> Option<&mut Json> {
+        match self {
+            Json::Object(pairs) => pairs.iter_mut().find(|(k, _)| k == key).map(|(_, v)| v),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            Json::String(s) => Some(s.as_str()),
+            _ => None,
+        }
+    }
+
+    pub fn as_array(&self) -> Option<&[Json]> {
+        match self {
+            Json::Array(items) => Some(items.as_slice()),
+            _ => None,
+        }
+    }
+
+    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Json>> {
+        match self {
+            Json::Array(items) => Some(items),
+            _ => None,
+        }
+    }
+
+    pub fn as_object(&self) -> Option<&[(String, Json)]> {
+        match self {
+            Json::Object(pairs) => Some(pairs.as_slice()),
+            _ => None,
+        }
+    }
+
+    /// Ruby truthiness: everything except `false` and `null` is true.
+    pub fn as_bool(&self) -> bool {
+        !matches!(self, Json::Bool(false) | Json::Null)
+    }
+
+    /// Iterates an array field; empty for any other value.
+    pub fn each(&self) -> &[Json] {
+        self.as_array().unwrap_or(&[])
+    }
+
+    /// Sets `key` to `value`, the only mutation the optional-marking pass performs.
+    /// Overwrites the existing pair, or appends one if absent.
+    pub fn set_bool(&mut self, key: &str, value: bool) {
+        if let Json::Object(pairs) = self {
+            if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
+                *existing = Json::Bool(value);
+                return;
+            }
+            pairs.push((key.to_string(), Json::Bool(value)));
+        }
+    }
+
+    /// Sets `key` to `value`, overwriting in place or else appending last.
+    pub fn set(&mut self, key: &str, value: Json) {
+        if let Json::Object(pairs) = self {
+            if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
+                *existing = value;
+                return;
+            }
+            pairs.push((key.to_string(), value));
+        }
+    }
+}
+
+struct Parser<'a> {
+    bytes: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> Parser<'a> {
+    fn peek(&self) -> Option<u8> {
+        self.bytes.get(self.pos).copied()
+    }
+
+    fn skip_ws(&mut self) {
+        while let Some(b) = self.peek() {
+            if b == b' ' || b == b'\t' || b == b'\n' || b == b'\r' {
+                self.pos += 1;
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn expect(&mut self, b: u8) -> Result<(), String> {
+        if self.peek() == Some(b) {
+            self.pos += 1;
+            Ok(())
+        } else {
+            Err(format!("expected {:?} at byte {}, found {:?}", b as char, self.pos, self.peek().map(|c| c as char)))
+        }
+    }
+
+    fn parse_value(&mut self) -> Result<Json, String> {
+        self.skip_ws();
+        match self.peek() {
+            Some(b'{') => self.parse_object(),
+            Some(b'[') => self.parse_array(),
+            Some(b'"') => Ok(Json::String(self.parse_string()?)),
+            Some(b't') => {
+                self.expect_literal("true")?;
+                Ok(Json::Bool(true))
+            }
+            Some(b'f') => {
+                self.expect_literal("false")?;
+                Ok(Json::Bool(false))
+            }
+            Some(b'n') => {
+                self.expect_literal("null")?;
+                Ok(Json::Null)
+            }
+            Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
+            other => Err(format!("unexpected byte {:?} at {}", other.map(|c| c as char), self.pos)),
+        }
+    }
+
+    fn expect_literal(&mut self, lit: &str) -> Result<(), String> {
+        let end = self.pos + lit.len();
+        if end <= self.bytes.len() && &self.bytes[self.pos..end] == lit.as_bytes() {
+            self.pos = end;
+            Ok(())
+        } else {
+            Err(format!("expected literal {lit:?} at byte {}", self.pos))
+        }
+    }
+
+    fn parse_object(&mut self) -> Result<Json, String> {
+        self.expect(b'{')?;
+        let mut pairs = Vec::new();
+        self.skip_ws();
+        if self.peek() == Some(b'}') {
+            self.pos += 1;
+            return Ok(Json::Object(pairs));
+        }
+        loop {
+            self.skip_ws();
+            let key = self.parse_string()?;
+            self.skip_ws();
+            self.expect(b':')?;
+            let value = self.parse_value()?;
+            pairs.push((key, value));
+            self.skip_ws();
+            match self.peek() {
+                Some(b',') => {
+                    self.pos += 1;
+                }
+                Some(b'}') => {
+                    self.pos += 1;
+                    break;
+                }
+                other => return Err(format!("expected ',' or '}}' at byte {}, found {:?}", self.pos, other.map(|c| c as char))),
+            }
+        }
+        Ok(Json::Object(pairs))
+    }
+
+    fn parse_array(&mut self) -> Result<Json, String> {
+        self.expect(b'[')?;
+        let mut items = Vec::new();
+        self.skip_ws();
+        if self.peek() == Some(b']') {
+            self.pos += 1;
+            return Ok(Json::Array(items));
+        }
+        loop {
+            let value = self.parse_value()?;
+            items.push(value);
+            self.skip_ws();
+            match self.peek() {
+                Some(b',') => {
+                    self.pos += 1;
+                }
+                Some(b']') => {
+                    self.pos += 1;
+                    break;
+                }
+                other => return Err(format!("expected ',' or ']' at byte {}, found {:?}", self.pos, other.map(|c| c as char))),
+            }
+        }
+        Ok(Json::Array(items))
+    }
+
+    fn parse_string(&mut self) -> Result<String, String> {
+        self.expect(b'"')?;
+        let mut out = String::new();
+        loop {
+            match self.peek() {
+                None => return Err("unterminated string".to_string()),
+                Some(b'"') => {
+                    self.pos += 1;
+                    break;
+                }
+                Some(b'\\') => {
+                    self.pos += 1;
+                    match self.peek() {
+                        Some(b'"') => {
+                            out.push('"');
+                            self.pos += 1;
+                        }
+                        Some(b'\\') => {
+                            out.push('\\');
+                            self.pos += 1;
+                        }
+                        Some(b'/') => {
+                            out.push('/');
+                            self.pos += 1;
+                        }
+                        Some(b'n') => {
+                            out.push('\n');
+                            self.pos += 1;
+                        }
+                        Some(b't') => {
+                            out.push('\t');
+                            self.pos += 1;
+                        }
+                        Some(b'r') => {
+                            out.push('\r');
+                            self.pos += 1;
+                        }
+                        Some(b'b') => {
+                            out.push('\u{8}');
+                            self.pos += 1;
+                        }
+                        Some(b'f') => {
+                            out.push('\u{c}');
+                            self.pos += 1;
+                        }
+                        Some(b'u') => {
+                            self.pos += 1;
+                            let hex = std::str::from_utf8(&self.bytes[self.pos..self.pos + 4]).map_err(|e| e.to_string())?;
+                            let code = u32::from_str_radix(hex, 16).map_err(|e| e.to_string())?;
+                            self.pos += 4;
+                            if let Some(c) = char::from_u32(code) {
+                                out.push(c);
+                            }
+                        }
+                        other => return Err(format!("bad escape {:?}", other.map(|c| c as char))),
+                    }
+                }
+                Some(_) => {
+                    // One UTF-8 char at a time so multi-byte text survives.
+                    let start = self.pos;
+                    let rest = std::str::from_utf8(&self.bytes[start..]).map_err(|e| e.to_string())?;
+                    let ch = rest.chars().next().ok_or("empty remainder")?;
+                    out.push(ch);
+                    self.pos += ch.len_utf8();
+                }
+            }
+        }
+        Ok(out)
+    }
+
+    // Keeps the raw literal text, so numbers round-trip unchanged.
+    fn parse_number(&mut self) -> Result<Json, String> {
+        let start = self.pos;
+        if self.peek() == Some(b'-') {
+            self.pos += 1;
+        }
+        while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
+            self.pos += 1;
+        }
+        if self.peek() == Some(b'.') {
+            self.pos += 1;
+            while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
+                self.pos += 1;
+            }
+        }
+        if matches!(self.peek(), Some(b'e') | Some(b'E')) {
+            self.pos += 1;
+            if matches!(self.peek(), Some(b'+') | Some(b'-')) {
+                self.pos += 1;
+            }
+            while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
+                self.pos += 1;
+            }
+        }
+        let text = std::str::from_utf8(&self.bytes[start..self.pos]).map_err(|e| e.to_string())?;
+        Ok(Json::Number(text.to_string()))
+    }
+}
+
+/// Renders `value` exactly as `JSON.pretty_generate` does for the pinned json gem.
+pub fn write(value: &Json) -> String {
+    let mut out = String::new();
+    write_value(&mut out, value, 0);
+    out
+}
+
+fn indent(out: &mut String, depth: usize) {
+    for _ in 0..depth {
+        out.push_str("  ");
+    }
+}
+
+fn write_value(out: &mut String, value: &Json, depth: usize) {
+    match value {
+        Json::Null => out.push_str("null"),
+        Json::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
+        Json::Number(n) => out.push_str(n),
+        Json::String(s) => write_string(out, s),
+        Json::Array(items) => write_array(out, items, depth),
+        Json::Object(pairs) => write_object(out, pairs, depth),
+    }
+}
+
+fn write_string(out: &mut String, text: &str) {
+    out.push('"');
+    for ch in text.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\t' => out.push_str("\\t"),
+            '\r' => out.push_str("\\r"),
+            c if (c as u32) < 0x20 => {
+                let _ = write!(out, "\\u{:04x}", c as u32);
+            }
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+}
+
+fn write_array(out: &mut String, items: &[Json], depth: usize) {
+    if items.is_empty() {
+        // Empty arrays render with a blank line, matching the pinned json gem.
+        out.push_str("[\n\n");
+        indent(out, depth);
+        out.push(']');
+        return;
+    }
+    out.push_str("[\n");
+    for (idx, item) in items.iter().enumerate() {
+        indent(out, depth + 1);
+        write_value(out, item, depth + 1);
+        if idx + 1 < items.len() {
+            out.push(',');
+        }
+        out.push('\n');
+    }
+    indent(out, depth);
+    out.push(']');
+}
+
+fn write_object(out: &mut String, pairs: &[(String, Json)], depth: usize) {
+    // An empty object needs no special case: the loop runs zero times.
+    out.push_str("{\n");
+    for (idx, (key, val)) in pairs.iter().enumerate() {
+        indent(out, depth + 1);
+        write_string(out, key);
+        out.push_str(": ");
+        write_value(out, val, depth + 1);
+        if idx + 1 < pairs.len() {
+            out.push(',');
+        }
+        out.push('\n');
+    }
+    indent(out, depth);
+    out.push('}');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trips_an_empty_object() {
+        let text = "{\n}";
+        let value = Json::parse(text).expect("parses");
+        assert_eq!(write(&value), text);
+    }
+
+    #[test]
+    fn set_bool_overwrites_an_existing_key() {
+        let mut value = Json::parse("{\n  \"optional\": false\n}").expect("parses");
+        value.set_bool("optional", true);
+        assert_eq!(write(&value), "{\n  \"optional\": true\n}");
+    }
+}