hecks 3.14.0 → 5.0.0

data/rust/codegen/src/hecks_naming.rs

@@ -1,9 +1,21 @@
-//! Port of the subset of `lib/hecks/naming.rb` that codegen calls:
-//! `snake`, `demodulise` and `reference_key`.
+//! The one Rust port of `lib/hecks/naming.rb`: `demodulise`, `reference_key`, `snake`, `pascal`,
+//! `plural` and `singularize`, std-only so every Cargo project here can compile this same file
+//! with `#[path = "..."] mod hecks_naming;` instead of keeping a copy that can drift.
+//!
+//! Each function follows the Ruby rule for rule. The Ruby patterns are ASCII-only while
+//! `String#downcase` and `String#upcase` use the full Unicode mapping a character at a time, so
+//! the boundaries below test ASCII and the case folds do not.
+//! `spec/fixtures/naming_vectors.json` is asserted by both runtimes.
 
-/// `type.to_s.split("::").last.to_s`
+/// `type.to_s.split("::").last.to_s`. Ruby's `split` drops trailing empty parts, so a trailing
+/// `::` names the segment before it.
 pub fn demodulise(type_name: &str) -> String {
-    type_name.rsplit("::").next().unwrap_or(type_name).to_string()
+    type_name
+        .split("::")
+        .filter(|part| !part.is_empty())
+        .last()
+        .unwrap_or("")
+        .to_string()
 }
 
 /// `snake(demodulise(type)).to_sym`
@@ -11,23 +23,119 @@ pub fn reference_key(type_name: &str) -> String {
     snake(&demodulise(type_name))
 }
 
-/// CamelCase to snake_case, matching Ruby's two-gsub `Naming.snake` in a single pass.
+/// `Naming.snake`: PascalCase or camelCase to snake_case.
 ///
-/// Inserts `_` before an uppercase letter that follows a lowercase letter or digit, or that
-/// ends an acronym (uppercase before, lowercase after).
-pub fn snake(text: &str) -> String {
-    let chars: Vec<char> = text.chars().collect();
+/// The two Ruby `gsub` passes (`([A-Z]+)([A-Z][a-z])` then `([a-z\d])([A-Z])`), then the
+/// per-character Unicode downcase.
+pub fn snake(name: &str) -> String {
+    ruby_downcase(&word_boundary(&acronym_boundary(name)))
+}
+
+/// Lowercases the way Ruby's `String#downcase` does: each character on its own, with the full
+/// Unicode mapping. `str::to_lowercase` differs in one place, a word-final capital sigma, which
+/// it turns into the final form `ς` where Ruby gives `σ`; and `to_ascii_lowercase` leaves every
+/// non-ASCII capital alone. Names derived from a bluebook must come out the same in both runtimes.
+pub fn ruby_downcase(text: &str) -> String {
+    text.chars().flat_map(char::to_lowercase).collect()
+}
+
+/// `Naming.pascal`: snake_case to PascalCase. Each `_`-separated part has its first character
+/// upcased with the full Unicode mapping, as `String#upcase` does.
+pub fn pascal(text: &str) -> String {
+    text.split('_')
+        .map(|part| {
+            let mut chars = part.chars();
+            chars.next().map_or_else(String::new, |first| {
+                first.to_uppercase().collect::<String>() + chars.as_str()
+            })
+        })
+        .collect()
+}
+
+/// `Naming.plural`: "y" after a consonant becomes "ies", a sibilant takes "es", else "s".
+pub fn plural(word: &str) -> String {
+    let mut tail = word.chars().rev();
+    if tail.next() == Some('y') && tail.next().is_some_and(|c| !"aeiou".contains(c)) {
+        return format!("{}ies", &word[..word.len() - 1]);
+    }
+    if ends_in_sibilant(word) {
+        return format!("{word}es");
+    }
+    format!("{word}s")
+}
+
+/// `Naming.singularize`: the crude inverse of `plural` ("ies" to "y", a sibilant's "es" and
+/// then a trailing "s" dropped); it only has to find a name someone already wrote.
+pub fn singularize(word: &str) -> String {
+    let length = word.chars().count();
+    if length > 3 {
+        if let Some(stem) = word.strip_suffix("ies") {
+            return format!("{stem}y");
+        }
+        // Undo `plural`'s "es" after s/x/z/ch/sh before the bare-"s" rule, so "Boxes" gives
+        // "Box" while "Invoices" still gives "Invoice".
+        if let Some(stem) = word.strip_suffix("es") {
+            if ends_in_sibilant(stem) {
+                return stem.to_string();
+            }
+        }
+    }
+    if length > 1 {
+        if let Some(stem) = word.strip_suffix('s') {
+            return stem.to_string();
+        }
+    }
+    word.to_string()
+}
+
+/// `/(s|x|z|ch|sh)\z/`
+fn ends_in_sibilant(word: &str) -> bool {
+    ["s", "x", "z", "ch", "sh"]
+        .iter()
+        .any(|suffix| word.ends_with(suffix))
+}
+
+/// The first `gsub`: `([A-Z]+)([A-Z][a-z])` becomes `\1_\2`.
+fn acronym_boundary(s: &str) -> String {
+    let chars: Vec<char> = s.chars().collect();
+    let mut out = String::new();
+    let mut i = 0;
+    while i < chars.len() {
+        if chars[i].is_ascii_uppercase() {
+            let mut j = i;
+            while j < chars.len() && chars[j].is_ascii_uppercase() {
+                j += 1;
+            }
+            let run_len = j - i;
+            if run_len >= 2 && j < chars.len() && chars[j].is_ascii_lowercase() {
+                out.extend(&chars[i..j - 1]);
+                out.push('_');
+                out.push(chars[j - 1]);
+                i = j;
+                continue;
+            }
+            out.extend(&chars[i..j]);
+            i = j;
+            continue;
+        }
+        out.push(chars[i]);
+        i += 1;
+    }
+    out
+}
+
+/// The second `gsub`: `([a-z\d])([A-Z])` becomes `\1_\2`, with `\d` ASCII as in Ruby.
+fn word_boundary(s: &str) -> String {
+    let chars: Vec<char> = s.chars().collect();
     let mut out = String::new();
-    for (i, &c) in chars.iter().enumerate() {
-        if c.is_ascii_uppercase() && i > 0 {
-            let prev = chars[i - 1];
-            let next = chars.get(i + 1).copied();
-            let insert = (prev.is_ascii_lowercase() || prev.is_ascii_digit()) || (prev.is_ascii_uppercase() && next.map(|n| n.is_ascii_lowercase()).unwrap_or(false));
-            if insert {
+    for (idx, &c) in chars.iter().enumerate() {
+        if idx > 0 && c.is_ascii_uppercase() {
+            let prev = chars[idx - 1];
+            if prev.is_ascii_lowercase() || prev.is_ascii_digit() {
                 out.push('_');
             }
         }
         out.push(c);
     }
-    out.to_lowercase()
+    out
 }

data/rust/codegen/src/hecks_naming_tests.rs

@@ -0,0 +1,81 @@
+//! Pins `hecks_naming` (the one Rust port of `lib/hecks/naming.rb`, compiled into several Cargo
+//! projects) against `spec/fixtures/naming_vectors.json`. `spec/naming_vectors_spec.rb` asserts
+//! the same tables against Ruby, so a drift in either runtime fails a test on its own side.
+//! Lives beside the shared file, not in it, because the file is std-only and the tests read JSON.
+
+use crate::hecks_naming::{
+    demodulise, pascal, plural, reference_key, ruby_downcase, singularize, snake,
+};
+use crate::json::Json;
+
+fn rows(section: &str) -> Vec<(String, String)> {
+    let table = Json::parse(include_str!("../../../spec/fixtures/naming_vectors.json")).unwrap();
+    let rows: Vec<(String, String)> = table
+        .get(section)
+        .unwrap_or_else(|| panic!("{section} table went missing"))
+        .each()
+        .iter()
+        .map(|row| {
+            (
+                row.get("input").unwrap().to_s(),
+                row.get("expected").unwrap().to_s(),
+            )
+        })
+        .collect();
+    assert!(!rows.is_empty(), "{section} rows went missing");
+    rows
+}
+
+fn assert_every_row(section: &str, rule: fn(&str) -> String) {
+    for (input, expected) in rows(section) {
+        assert_eq!(rule(&input), expected, "{section}({input:?})");
+    }
+}
+
+#[test]
+fn snake_matches_every_shared_row() {
+    assert_every_row("snake", snake);
+}
+
+#[test]
+fn storage_name_is_snake_of_the_demodulised_name() {
+    assert_every_row("storage_name", |input| snake(&demodulise(input)));
+}
+
+#[test]
+fn pascal_matches_every_shared_row() {
+    assert_every_row("pascal", pascal);
+}
+
+#[test]
+fn plural_matches_every_shared_row() {
+    assert_every_row("plural", plural);
+}
+
+#[test]
+fn singularize_matches_every_shared_row() {
+    assert_every_row("singularize", singularize);
+}
+
+#[test]
+fn demodulise_matches_every_shared_row() {
+    assert_every_row("demodulise", demodulise);
+}
+
+#[test]
+fn reference_key_matches_every_shared_row() {
+    assert_every_row("reference_key", reference_key);
+}
+
+#[test]
+fn ruby_downcase_folds_unicode_capitals_one_character_at_a_time() {
+    assert_eq!(ruby_downcase("ÉCOLE"), "école");
+    assert_eq!(ruby_downcase("ΟΔΥΣΣΕΑΣ"), "οδυσσεασ");
+    assert_eq!(ruby_downcase("ascii"), "ascii");
+}
+
+#[test]
+fn a_boxes_collection_names_the_box_aggregate_again() {
+    assert_eq!(singularize(&plural("Box")), "Box");
+    assert_eq!(singularize("Invoices"), "Invoice");
+}

data/rust/codegen/src/json.rs

@@ -12,10 +12,10 @@ pub enum Json {
     /// Raw literal text as scanned, so numbers round-trip unchanged; `number` reads it as Ruby wrote it.
     Number(String),
     String(String),
-    Array(Vec<Json>),
+    Array(Vec<Self>),
     /// Insertion-ordered pairs, matching the declaration order of the Ruby Hash; byte-exact
     /// re-emission depends on key order.
-    Object(Vec<(String, Json)>),
+    Object(Vec<(String, Self)>),
 }
 
 /// A `Json::Number` as Ruby wrote it: a `.` or an exponent means a Float, anything else an
@@ -27,8 +27,11 @@ pub enum Number {
 }
 
 impl Json {
-    pub fn parse(text: &str) -> Result<Json, String> {
-        let mut p = Parser { bytes: text.as_bytes(), pos: 0 };
+    pub fn parse(text: &str) -> Result<Self, String> {
+        let mut p = Parser {
+            bytes: text.as_bytes(),
+            pos: 0,
+        };
         p.skip_ws();
         let value = p.parse_value()?;
         p.skip_ws();
@@ -39,74 +42,80 @@ impl Json {
     }
 
     /// `ir[:key]`: `None` for a missing key or a `Json::Null` value.
-    pub fn get(&self, key: &str) -> Option<&Json> {
+    pub fn get(&self, key: &str) -> Option<&Self> {
         match self {
-            Json::Object(pairs) => pairs.iter().find(|(k, v)| k == key && !matches!(v, Json::Null)).map(|(_, v)| v),
+            Self::Object(pairs) => pairs
+                .iter()
+                .find(|(k, v)| k == key && !matches!(v, Self::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> {
+    pub fn get_raw(&self, key: &str) -> Option<&Self> {
         match self {
-            Json::Object(pairs) => pairs.iter().find(|(k, _)| k == key).map(|(_, v)| v),
+            Self::Object(pairs) => pairs.iter().find(|(k, _)| k == key).map(|(_, v)| v),
             _ => None,
         }
     }
 
-    pub fn get_mut(&mut self, key: &str) -> Option<&mut Json> {
+    pub fn get_mut(&mut self, key: &str) -> Option<&mut Self> {
         match self {
-            Json::Object(pairs) => pairs.iter_mut().find(|(k, _)| k == key).map(|(_, v)| v),
+            Self::Object(pairs) => pairs.iter_mut().find(|(k, _)| k == key).map(|(_, v)| v),
             _ => None,
         }
     }
 
-    pub fn as_str(&self) -> Option<&str> {
+    pub const fn as_str(&self) -> Option<&str> {
         match self {
-            Json::String(s) => Some(s.as_str()),
+            Self::String(s) => Some(s.as_str()),
             _ => None,
         }
     }
 
-    pub fn as_array(&self) -> Option<&[Json]> {
+    pub const fn as_array(&self) -> Option<&[Self]> {
         match self {
-            Json::Array(items) => Some(items.as_slice()),
+            Self::Array(items) => Some(items.as_slice()),
             _ => None,
         }
     }
 
-    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Json>> {
+    pub const fn as_array_mut(&mut self) -> Option<&mut Vec<Self>> {
         match self {
-            Json::Array(items) => Some(items),
+            Self::Array(items) => Some(items),
             _ => None,
         }
     }
 
-    pub fn as_object(&self) -> Option<&[(String, Json)]> {
+    pub const fn as_object(&self) -> Option<&[(String, Self)]> {
         match self {
-            Json::Object(pairs) => Some(pairs.as_slice()),
+            Self::Object(pairs) => Some(pairs.as_slice()),
             _ => None,
         }
     }
 
-    pub fn as_bool(&self) -> bool {
+    pub const 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)
+        !matches!(self, Self::Bool(false) | Self::Null)
     }
 
     /// The number as Ruby wrote it, or `None` for any other value. An integer too large for `i64`
     /// reads as a Float.
     pub fn number(&self) -> Option<Number> {
-        let Json::Number(text) = self else { return None };
-        if text.contains(|c| matches!(c, '.' | 'e' | 'E')) {
+        let Self::Number(text) = self else {
+            return None;
+        };
+        if text.contains(['.', 'e', 'E']) {
             return text.parse::<f64>().ok().map(Number::Float);
         }
-        match text.parse::<i64>() {
-            Ok(n) => Some(Number::Int(n)),
-            Err(_) => text.parse::<f64>().ok().map(Number::Float),
-        }
+        text.parse::<i64>().map_or_else(
+            |_| text.parse::<f64>().ok().map(Number::Float),
+            |n| Some(Number::Int(n)),
+        )
     }
 
+    #[cfg(test)]
     pub fn as_f64(&self) -> Option<f64> {
         self.number().map(|n| match n {
             Number::Int(n) => n as f64,
@@ -114,6 +123,7 @@ impl Json {
         })
     }
 
+    #[cfg(test)]
     pub fn as_i64(&self) -> Option<i64> {
         self.number().map(|n| match n {
             Number::Int(n) => n,
@@ -124,26 +134,26 @@ impl Json {
     /// `#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::Number(text) => match self.number() {
+            Self::Null => String::new(),
+            Self::Bool(b) => b.to_string(),
+            Self::Number(text) => match self.number() {
                 Some(Number::Int(n)) => n.to_string(),
                 Some(Number::Float(n)) => format_number(n),
                 None => text.clone(),
             },
-            Json::String(s) => s.clone(),
+            Self::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] {
+    pub fn each(&self) -> &[Self] {
         self.as_array().unwrap_or(&[])
     }
 
     /// 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 {
+    pub fn set(&mut self, key: &str, value: Self) {
+        if let Self::Object(pairs) = self {
             if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
                 *existing = value;
                 return;
@@ -153,7 +163,7 @@ impl Json {
     }
 
     pub fn set_bool(&mut self, key: &str, value: bool) {
-        self.set(key, Json::Bool(value));
+        self.set(key, Self::Bool(value));
     }
 }
 
@@ -178,7 +188,7 @@ struct Parser<'a> {
     pos: usize,
 }
 
-impl<'a> Parser<'a> {
+impl Parser<'_> {
     fn peek(&self) -> Option<u8> {
         self.bytes.get(self.pos).copied()
     }
@@ -198,7 +208,12 @@ impl<'a> Parser<'a> {
             self.pos += 1;
             Ok(())
         } else {
-            Err(format!("expected {:?} at byte {}, found {:?}", b as char, self.pos, self.peek().map(|c| c as char)))
+            Err(format!(
+                "expected {:?} at byte {}, found {:?}",
+                b as char,
+                self.pos,
+                self.peek().map(|c| c as char)
+            ))
         }
     }
 
@@ -221,7 +236,11 @@ impl<'a> Parser<'a> {
                 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)),
+            other => Err(format!(
+                "unexpected byte {:?} at {}",
+                other.map(|c| c as char),
+                self.pos
+            )),
         }
     }
 
@@ -259,7 +278,13 @@ impl<'a> Parser<'a> {
                     self.pos += 1;
                     break;
                 }
-                other => return Err(format!("expected ',' or '}}' at byte {}, found {:?}", self.pos, other.map(|c| c as char))),
+                other => {
+                    return Err(format!(
+                        "expected ',' or '}}' at byte {}, found {:?}",
+                        self.pos,
+                        other.map(|c| c as char)
+                    ))
+                }
             }
         }
         Ok(Json::Object(pairs))
@@ -285,7 +310,13 @@ impl<'a> Parser<'a> {
                     self.pos += 1;
                     break;
                 }
-                other => return Err(format!("expected ',' or ']' at byte {}, found {:?}", self.pos, other.map(|c| c as char))),
+                other => {
+                    return Err(format!(
+                        "expected ',' or ']' at byte {}, found {:?}",
+                        self.pos,
+                        other.map(|c| c as char)
+                    ))
+                }
             }
         }
         Ok(Json::Array(items))
@@ -338,7 +369,8 @@ impl<'a> Parser<'a> {
                         }
                         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 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) {
@@ -351,7 +383,8 @@ impl<'a> Parser<'a> {
                 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 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();
@@ -376,9 +409,9 @@ impl<'a> Parser<'a> {
                 self.pos += 1;
             }
         }
-        if matches!(self.peek(), Some(b'e') | Some(b'E')) {
+        if matches!(self.peek(), Some(b'e' | b'E')) {
             self.pos += 1;
-            if matches!(self.peek(), Some(b'+') | Some(b'-')) {
+            if matches!(self.peek(), Some(b'+' | b'-')) {
                 self.pos += 1;
             }
             while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
@@ -498,7 +531,10 @@ mod tests {
         assert_eq!(numbers[1], Some(Number::Int(0)));
         assert_eq!(numbers[2], Some(Number::Float(1000.0)));
         assert_eq!(numbers[3], Some(Number::Int(-7)));
-        assert!(matches!(numbers[4], Some(Number::Float(_))), "an integer past i64 reads as a Float");
+        assert!(
+            matches!(numbers[4], Some(Number::Float(_))),
+            "an integer past i64 reads as a Float"
+        );
         assert_eq!(value.each()[0].to_s(), "0.0");
         assert_eq!(value.each()[1].to_s(), "0");
     }