hecks 3.14.0 → 4.0.0

data/rust/parser/src/build/naming.rs

@@ -1,13 +1,7 @@
 //! Pure name-shape conversions (mirrors `Hecks::Naming`) shared by the other derivations.
 
-/// `"Pizzas::Order" -> "Order"`.
-pub fn demodulise(type_name: &str) -> String {
-    type_name
-        .rsplit("::")
-        .next()
-        .unwrap_or(type_name)
-        .to_string()
-}
+// The name-shape rules are the one shared port of `Hecks::Naming` (rust/codegen/src/hecks_naming.rs).
+pub use crate::hecks_naming::{demodulise, pascal, plural, singularize, snake};
 
 /// A bare command constant (`Account::Debit`) becomes `Account.Debit`; strings pass through.
 ///
@@ -34,78 +28,6 @@ pub fn event_name_ref(raw: &str) -> String {
     }
 }
 
-/// `"PizzaName" -> "pizza_name"`, using the same two-pass split as `Hecks::Naming.snake`.
-pub fn snake(text: &str) -> String {
-    let chars: Vec<char> = text.chars().collect();
-    let mut pass1 = String::new();
-    for (i, &ch) in chars.iter().enumerate() {
-        let is_upper_run_boundary = ch.is_ascii_uppercase()
-            && i > 0
-            && chars[i - 1].is_ascii_uppercase()
-            && i + 1 < chars.len()
-            && chars[i + 1].is_ascii_lowercase();
-        if is_upper_run_boundary {
-            pass1.push('_');
-        }
-        pass1.push(ch);
-    }
-
-    let pass1_chars: Vec<char> = pass1.chars().collect();
-    let mut pass2 = String::new();
-    for (i, &ch) in pass1_chars.iter().enumerate() {
-        let is_lower_to_upper_boundary = ch.is_ascii_uppercase()
-            && i > 0
-            && (pass1_chars[i - 1].is_ascii_lowercase() || pass1_chars[i - 1].is_ascii_digit());
-        if is_lower_to_upper_boundary {
-            pass2.push('_');
-        }
-        pass2.push(ch);
-    }
-
-    pass2.to_lowercase()
-}
-
-/// `"pizza_name" -> "PizzaName"`.
-pub fn pascal(text: &str) -> String {
-    text.split('_')
-        .map(|part| {
-            let mut chars = part.chars();
-            match chars.next() {
-                Some(first) => first.to_ascii_uppercase().to_string() + chars.as_str(),
-                None => String::new(),
-            }
-        })
-        .collect()
-}
-
-/// Pluralizes a snake-cased name: `y` -> `ies`, sibilants take `es`, else `s`.
-pub fn plural(text: &str) -> String {
-    if text.len() > 1 {
-        let last = &text[text.len() - 1..];
-        let before_last = text.chars().rev().nth(1);
-        if last == "y" && !matches!(before_last, Some('a' | 'e' | 'i' | 'o' | 'u')) {
-            return format!("{}ies", &text[..text.len() - 1]);
-        }
-    }
-    for suffix in ["s", "x", "z", "ch", "sh"] {
-        if text.ends_with(suffix) {
-            return format!("{text}es");
-        }
-    }
-    format!("{text}s")
-}
-
-/// Inverse of `plural` for `has_many` targets: `ies` -> `y`, trailing `s` dropped.
-pub fn singularize(text: &str) -> String {
-    if text.len() > 3 && text.ends_with("ies") {
-        return format!("{}y", &text[..text.len() - 3]);
-    }
-    if text.len() > 1 && text.ends_with('s') {
-        return text[..text.len() - 1].to_string();
-    }
-    text.to_string()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

data/rust/parser/src/build/pattern_subset.rs

@@ -17,13 +17,10 @@ pub fn validate(pattern: &str) -> Option<Rejection> {
             if matches!(next, Some(c) if c.is_ascii_digit() && c != '0') {
                 return Some(refuse("backreference"));
             }
-            if matches!(next, Some('k') | Some('g')) {
+            if matches!(next, Some('k' | 'g')) {
                 return Some(refuse("named_backreference"));
             }
-            if matches!(
-                next,
-                Some('d') | Some('D') | Some('w') | Some('W') | Some('s') | Some('S')
-            ) {
+            if matches!(next, Some('d' | 'D' | 'w' | 'W' | 's' | 'S')) {
                 return Some(refuse("perl_class"));
             }
             index += if next.is_some() { 2 } else { 1 };
@@ -32,11 +29,10 @@ pub fn validate(pattern: &str) -> Option<Rejection> {
 
         if chars[index] == '(' && chars.get(index + 1) == Some(&'?') {
             let third = chars.get(index + 2).copied();
-            if matches!(third, Some('=') | Some('!')) {
+            if matches!(third, Some('=' | '!')) {
                 return Some(refuse("lookahead"));
             }
-            if third == Some('<') && matches!(chars.get(index + 3).copied(), Some('=') | Some('!'))
-            {
+            if third == Some('<') && matches!(chars.get(index + 3).copied(), Some('=' | '!')) {
                 return Some(refuse("lookbehind"));
             }
             if third == Some('>') {
@@ -58,6 +54,8 @@ pub fn validate(pattern: &str) -> Option<Rejection> {
 }
 
 fn refuse(key: &'static str) -> Rejection {
+    // reason: every caller passes a key literal that `REASONS` declares, so a miss is a code bug.
+    #[allow(clippy::expect_used)]
     let (construct, reason) = REASONS
         .iter()
         .find(|(k, _, _)| *k == key)

data/rust/parser/src/build/query_derive.rs

@@ -65,7 +65,9 @@ mod tests {
     fn refuses_an_on_target_cleanly_instead_of_silently_dropping_or_misparsing_it() {
         let named = vec![("on".to_string(), "Character".to_string())];
         let err = refuse_on_target("f.bluebook", 3, "where", &named).unwrap_err();
-        assert!(err.message.contains("on: ...) — per-target read-model filtering (ADR 0055)"));
+        assert!(err
+            .message
+            .contains("on: ...) — per-target read-model filtering (ADR 0055)"));
         assert_eq!(err.file, "f.bluebook");
         assert_eq!(err.line, 3);
     }

data/rust/parser/src/build/query_inference.rs

@@ -9,10 +9,13 @@ pub fn apply(file: &str, bluebook: &mut ir::Bluebook) -> ParseResult<()> {
     let shapes = bluebook.aggregates.clone();
 
     for aggregate in &mut bluebook.aggregates {
-        let owner = shapes
+        // `shapes` is a clone of these aggregates, so the lookup always hits.
+        let Some(owner) = shapes
             .iter()
             .find(|candidate| candidate.name == aggregate.name)
-            .expect("aggregate cloned from the same chapter");
+        else {
+            continue;
+        };
 
         infer_queries(
             file,
@@ -25,11 +28,14 @@ pub fn apply(file: &str, bluebook: &mut ir::Bluebook) -> ParseResult<()> {
         )?;
 
         for entity in &mut aggregate.entities {
-            let entity_shape = owner
+            // `owner.entities` is a clone of these entities, so the lookup always hits.
+            let Some(entity_shape) = owner
                 .entities
                 .iter()
                 .find(|candidate| candidate.name == entity.name)
-                .expect("entity cloned from the same aggregate");
+            else {
+                continue;
+            };
             infer_queries(
                 file,
                 &format!("{}::{}", aggregate.name, entity.name),
@@ -239,7 +245,10 @@ mod tests {
                 ir::Query {
                     name: "Page".to_string(),
                     options: ir::QueryOptions {
-                        offset: Some(ir::OffsetSpec { value: ":start_at".to_string(), target: None }),
+                        offset: Some(ir::OffsetSpec {
+                            value: ":start_at".to_string(),
+                            target: None,
+                        }),
                         ..Default::default()
                     },
                     ..Default::default()

data/rust/parser/src/build/read_model.rs

@@ -73,7 +73,10 @@ mod tests {
             Some("Account"),
         )
         .unwrap();
-        assert!(heads[0].many, "no included head equals the reference target, so all stay many");
+        assert!(
+            heads[0].many,
+            "no included head equals the reference target, so all stay many"
+        );
     }
 
     #[test]

data/rust/parser/src/build/references.rs

@@ -6,9 +6,10 @@ use crate::ir;
 /// with no `_id` suffix.
 pub fn reference_attribute(target: &str, as_name: Option<&str>, optional: bool) -> ir::Attribute {
     let target = crate::build::naming::demodulise(target);
-    let name = as_name
-        .map(|s| s.to_string())
-        .unwrap_or_else(|| crate::build::naming::snake(&target));
+    let name = as_name.map_or_else(
+        || crate::build::naming::snake(&target),
+        std::string::ToString::to_string,
+    );
     ir::Attribute {
         name,
         type_name: format!("Reference<{target}>"),

data/rust/parser/src/canonical.rs

@@ -2,6 +2,7 @@
 //! Hand-mirrored from projection.json: a rule there (collapse_whitespace, replace, scale_call) needs a matching rule here.
 
 /// Slices the raw source between two byte offsets, before any normalisation.
+#[cfg(test)]
 pub fn slice(source: &str, start: usize, end: usize) -> &str {
     &source[start..end]
 }
@@ -10,7 +11,9 @@ pub fn slice(source: &str, start: usize, end: usize) -> &str {
 /// becomes `.size`, then trim. Quoted runs pass through untouched, matching Ruby.
 pub fn apply(source: &str) -> String {
     let collapsed = map_outside_strings(source, collapse_whitespace);
-    let replaced = map_outside_strings(&collapsed, |run| replace_word_boundary(run, ".length", ".size"));
+    let replaced = map_outside_strings(&collapsed, |run| {
+        replace_word_boundary(run, ".length", ".size")
+    });
     let scaled = SCALE_CALLS.iter().fold(replaced, |text, (token, seconds)| {
         map_outside_strings(&text, |run| scale_call(run, token, seconds))
     });
@@ -41,7 +44,7 @@ fn scale_call(text: &str, token: &str, seconds: &str) -> String {
             let preceded = text[..i]
                 .chars()
                 .next_back()
-                .map_or(false, |c| c.is_alphanumeric() || c == '_' || c == '.');
+                .is_some_and(|c| c.is_alphanumeric() || c == '_' || c == '.');
             if !preceded {
                 if let Some((digits, len)) = whole_number_call(&text[i + token.len()..]) {
                     out.push_str(&multiply(digits, seconds));
@@ -50,7 +53,9 @@ fn scale_call(text: &str, token: &str, seconds: &str) -> String {
                 }
             }
         }
-        let ch = text[i..].chars().next().unwrap();
+        let Some(ch) = text[i..].chars().next() else {
+            break;
+        };
         out.push(ch);
         i += ch.len_utf8();
     }
@@ -63,7 +68,7 @@ fn whole_number_call(rest: &str) -> Option<(&str, usize)> {
     let inner = rest.strip_prefix('(')?;
     let digits_at = inner.len() - inner.trim_start_matches(char::is_whitespace).len();
     let body = &inner[digits_at..];
-    let digit_len = body.bytes().take_while(|b| b.is_ascii_digit()).count();
+    let digit_len = body.bytes().take_while(u8::is_ascii_digit).count();
     if digit_len == 0 {
         return None;
     }
@@ -75,11 +80,13 @@ fn whole_number_call(rest: &str) -> Option<(&str, usize)> {
 
 /// Decimal `digits` times the decimal `factor`, as text with no leading zeros (any length).
 fn multiply(digits: &str, factor: &str) -> String {
+    // reason: callers pass the fixed whole-number scale factors of the unit table.
+    #[allow(clippy::expect_used)]
     let factor: u32 = factor.parse().expect("scale factor is a whole number");
     let mut carry = 0u32;
     let mut out: Vec<u8> = Vec::with_capacity(digits.len() + 6);
     for d in digits.bytes().rev() {
-        let v = (d - b'0') as u32 * factor + carry;
+        let v = u32::from(d - b'0') * factor + carry;
         out.push(b'0' + (v % 10) as u8);
         carry = v / 10;
     }
@@ -91,7 +98,7 @@ fn multiply(digits: &str, factor: &str) -> String {
         out.pop();
     }
     out.reverse();
-    String::from_utf8(out).unwrap()
+    String::from_utf8_lossy(&out).into_owned()
 }
 
 /// Applies `transform` to the unquoted runs of `text` and copies quoted runs verbatim;
@@ -99,7 +106,7 @@ fn multiply(digits: &str, factor: &str) -> String {
 fn map_outside_strings(text: &str, transform: impl Fn(&str) -> String) -> String {
     let mut out = String::with_capacity(text.len());
     let mut plain = String::new();
-    let mut chars = text.chars().peekable();
+    let mut chars = text.chars();
     while let Some(ch) = chars.next() {
         if ch == '"' || ch == '\'' {
             out.push_str(&transform(&plain));
@@ -151,17 +158,19 @@ fn replace_word_boundary(text: &str, token: &str, replacement: &str) -> String {
     while i < bytes.len() {
         if text[i..].starts_with(token) {
             let after = i + token.len();
-            let boundary_ok = match text[after..].chars().next() {
-                None => true,
-                Some(c) => !(c.is_alphanumeric() || c == '_'),
-            };
+            let boundary_ok = text[after..]
+                .chars()
+                .next()
+                .is_none_or(|c| !(c.is_alphanumeric() || c == '_'));
             if boundary_ok {
                 out.push_str(replacement);
                 i = after;
                 continue;
             }
         }
-        let ch = text[i..].chars().next().unwrap();
+        let Some(ch) = text[i..].chars().next() else {
+            break;
+        };
         out.push(ch);
         i += ch.len_utf8();
     }
@@ -187,7 +196,10 @@ mod tests {
     #[test]
     fn folds_duration_calls_into_seconds() {
         assert_eq!(apply("days(730)"), "63072000");
-        assert_eq!(apply("days( 1 ) + hours(2) + minutes(15)"), "86400 + 7200 + 900");
+        assert_eq!(
+            apply("days( 1 ) + hours(2) + minutes(15)"),
+            "86400 + 7200 + 900"
+        );
         assert_eq!(
             apply("x.days(3) workdays(3) days(n) days(1.5)"),
             "x.days(3) workdays(3) days(n) days(1.5)"
@@ -227,10 +239,17 @@ mod tests {
 
     #[test]
     fn matches_the_shared_canonical_form_cases() {
-        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../../spec/fixtures/canonical_form_cases.json");
+        let path = concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../spec/fixtures/canonical_form_cases.json"
+        );
         let text = std::fs::read_to_string(path).expect("shared cases file");
         let strings = json_strings(&text);
-        let start = strings.iter().position(|s| s == "cases").expect("cases key") + 1;
+        let start = strings
+            .iter()
+            .position(|s| s == "cases")
+            .expect("cases key")
+            + 1;
         let rows: Vec<&[String]> = strings[start..].chunks(4).collect();
         assert!(!rows.is_empty());
         for row in rows {