hecks 2.9.0 → 3.0.0

data/rust/codegen/src/json.rs

@@ -0,0 +1,335 @@
+//! A minimal, dependency-free JSON reader indexed by string key, like the Ruby `ir[:key]` Hash.
+//! It is read-only: this crate emits Rust source, never JSON.
+
+use std::fmt;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Json {
+    Null,
+    Bool(bool),
+    // Kept apart from Float: a whole-number Float default (`0.0`) must not render as `0`.
+    Int(i64),
+    Float(f64),
+    String(String),
+    Array(Vec<Json>),
+    // Insertion-ordered pairs, matching the declaration order of the Ruby Hash.
+    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)
+    }
+
+    /// `ir[:key]`: `None` for a missing key or a `Json::Null` value.
+    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,
+        }
+    }
+
+    /// Like `get`, but distinguishes an absent key from one present as null.
+    pub fn get_raw(&self, key: &str) -> Option<&Json> {
+        match self {
+            Json::Object(pairs) => pairs.iter().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_bool(&self) -> bool {
+        // Ruby truthiness: only `false` and `nil` are falsy, so `0` and `""` are truthy.
+        !matches!(self, Json::Bool(false) | Json::Null)
+    }
+
+    pub fn as_f64(&self) -> Option<f64> {
+        match self {
+            Json::Int(n) => Some(*n as f64),
+            Json::Float(n) => Some(*n),
+            _ => None,
+        }
+    }
+
+    pub fn as_i64(&self) -> Option<i64> {
+        match self {
+            Json::Int(n) => Some(*n),
+            Json::Float(n) => Some(*n as i64),
+            _ => None,
+        }
+    }
+
+    /// `#to_s` on a scalar; non-scalars render as the empty string rather than panicking.
+    pub fn to_s(&self) -> String {
+        match self {
+            Json::Null => String::new(),
+            Json::Bool(b) => b.to_string(),
+            Json::Int(n) => n.to_string(),
+            Json::Float(n) => format_number(*n),
+            Json::String(s) => s.clone(),
+            _ => String::new(),
+        }
+    }
+
+    /// Array items, or an empty slice for any other value (Ruby's `Array(ir[:key])`).
+    pub fn each(&self) -> &[Json] {
+        self.as_array().unwrap_or(&[])
+    }
+}
+
+impl fmt::Display for Json {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.to_s())
+    }
+}
+
+/// Ruby's `Float#to_s`: always carries a decimal point (`0.0`), unlike Rust's `{}`.
+fn format_number(n: f64) -> String {
+    let text = format!("{n}");
+    if text.contains('.') || text.contains('e') || text.contains('E') {
+        text
+    } else {
+        format!("{text}.0")
+    }
+}
+
+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 intact.
+                    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)
+    }
+
+    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())?;
+        // A `.` or exponent means Ruby wrote a Float; otherwise an Integer (see `Json::Int`).
+        if text.contains('.') || text.contains('e') || text.contains('E') {
+            text.parse::<f64>().map(Json::Float).map_err(|e| e.to_string())
+        } else {
+            text.parse::<i64>().map(Json::Int).map_err(|e| e.to_string())
+        }
+    }
+}