hecks 3.2.1 → 3.3.0

data/rust/build/src/json.rs

@@ -1,421 +0,0 @@
-//! 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}");
-    }
-}

data/rust/build/src/optional_pass.rs

@@ -1,150 +0,0 @@
-//! Marks value-object and entity fields `optional` when an `append` mutation binds them to an
-//! optional command argument, so the generated struct field is an `Option`.
-
-use crate::json::Json;
-
-pub fn run(ir: &mut Json) {
-    if let Some(aggregates) = ir.get_mut("aggregates").and_then(Json::as_array_mut) {
-        for aggregate in aggregates.iter_mut() {
-            mark_append_optional_fields(aggregate);
-        }
-    }
-}
-
-enum ElementRef {
-    ValueObject(usize),
-    Entity(usize),
-}
-
-fn find_element_ref(aggregate: &Json, target_type: &str) -> Option<ElementRef> {
-    if let Some(idx) = aggregate.get("value_objects").map(Json::each).unwrap_or(&[]).iter().position(|vo| vo.get("name").and_then(Json::as_str) == Some(target_type)) {
-        return Some(ElementRef::ValueObject(idx));
-    }
-    if let Some(idx) = aggregate.get("entities").map(Json::each).unwrap_or(&[]).iter().position(|e| e.get("name").and_then(Json::as_str) == Some(target_type)) {
-        return Some(ElementRef::Entity(idx));
-    }
-    None
-}
-
-// Gathers the fields to mark first, then applies them: the commands are read while the
-// value objects and entities are mutated.
-fn mark_append_optional_fields(aggregate: &mut Json) {
-    let target_attrs: Vec<(String, String)> = aggregate
-        .get("attributes")
-        .map(Json::each)
-        .unwrap_or(&[])
-        .iter()
-        .filter_map(|a| {
-            let name = a.get("name").and_then(Json::as_str)?;
-            let type_name = a.get("type").and_then(Json::as_str)?;
-            Some((name.to_string(), type_name.to_string()))
-        })
-        .collect();
-
-    for (attr_name, attr_type) in target_attrs {
-        let Some(element_ref) = find_element_ref(aggregate, &attr_type) else { continue };
-
-        let fields_to_mark = collect_fields_to_mark(aggregate, &attr_name);
-        if fields_to_mark.is_empty() {
-            continue;
-        }
-
-        apply_marks(aggregate, &element_ref, &fields_to_mark);
-    }
-}
-
-fn collect_fields_to_mark(aggregate: &Json, target_attr_name: &str) -> Vec<String> {
-    let mut out = Vec::new();
-
-    for command in aggregate.get("commands").map(Json::each).unwrap_or(&[]) {
-        let command_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-
-        for mutation in command.get("mutations").map(Json::each).unwrap_or(&[]) {
-            let op = mutation.get("op").and_then(Json::as_str).unwrap_or("");
-            let target = mutation.get("target").and_then(Json::as_str).unwrap_or("");
-            if op != "append" || target != target_attr_name {
-                continue;
-            }
-
-            let Some(fields) = mutation.get("fields").and_then(Json::as_object) else { continue };
-            for (field_name, source) in fields {
-                // Only a Symbol (an argument name) renders with a leading `:` in `Literal.render`.
-                let Some(source_text) = source.as_str() else { continue };
-                let Some(arg_name) = source_text.strip_prefix(':') else { continue };
-
-                let source_is_optional = command_attrs.iter().any(|a| {
-                    a.get("name").and_then(Json::as_str) == Some(arg_name) && a.get("optional").map(Json::as_bool).unwrap_or(false)
-                });
-                if source_is_optional {
-                    out.push(field_name.clone());
-                }
-            }
-        }
-    }
-
-    out
-}
-
-fn apply_marks(aggregate: &mut Json, element_ref: &ElementRef, fields_to_mark: &[String]) {
-    let element = match element_ref {
-        ElementRef::ValueObject(idx) => aggregate.get_mut("value_objects").and_then(Json::as_array_mut).and_then(|v| v.get_mut(*idx)),
-        ElementRef::Entity(idx) => aggregate.get_mut("entities").and_then(Json::as_array_mut).and_then(|v| v.get_mut(*idx)),
-    };
-    let Some(element) = element else { return };
-    let Some(attrs) = element.get_mut("attributes").and_then(Json::as_array_mut) else { return };
-
-    for field_name in fields_to_mark {
-        if let Some(field_attr) = attrs.iter_mut().find(|a| a.get("name").and_then(Json::as_str) == Some(field_name.as_str())) {
-            field_attr.set_bool("optional", true);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // Banking's `Account.Credit` shape: entity list `ledger`, one `append` binding `amount` from
-    // an optional argument and `direction` from a literal Hash.
-    fn fixture() -> Json {
-        Json::parse(
-            r#"{
-  "attributes": [
-    {"name": "ledger", "type": "LedgerEntry", "list": true, "default": null, "optional": false, "pattern": null, "admits": null}
-  ],
-  "value_objects": [],
-  "entities": [
-    {
-      "name": "LedgerEntry",
-      "attributes": [
-        {"name": "amount", "type": "Money", "list": false, "default": null, "optional": false, "pattern": null, "admits": null},
-        {"name": "direction", "type": "Direction", "list": false, "default": null, "optional": false, "pattern": null, "admits": null}
-      ]
-    }
-  ],
-  "commands": [
-    {
-      "name": "Credit",
-      "attributes": [
-        {"name": "amount", "type": "PositiveMoney", "list": false, "default": null, "optional": true, "pattern": null, "admits": null}
-      ],
-      "mutations": [
-        {"target": "ledger", "op": "append", "fields": {"amount": ":amount", "direction": "{value: \"credit\"}"}}
-      ]
-    }
-  ]
-}"#,
-        )
-        .expect("fixture parses")
-    }
-
-    #[test]
-    fn marks_the_argument_sourced_field_optional() {
-        let mut aggregate = fixture();
-        mark_append_optional_fields(&mut aggregate);
-
-        let entity = &aggregate.get("entities").unwrap().each()[0];
-        let amount = entity.get("attributes").unwrap().each().iter().find(|a| a.get("name").and_then(Json::as_str) == Some("amount")).unwrap();
-        assert!(amount.get("optional").unwrap().as_bool());
-    }
-}