feat(ogar-from-ruff): prove emit_rust on a Rails-lifted CompiledClass

Step 2 of the gating order in the OP+Redmine convergence handover
(openproject-nexgen-rs .claude/handovers/2026-06-30-1200-...md §4): before
this commit, emit_rust/csharp/python had only ever run on an Odoo-lifted
CompiledClass (compile_graph_python, in emit.rs's own tests). This adds
a Rails fixture (compile_graph_ruby::<OpenProjectPort> on a WorkPackage
graph with a typed attribute, an untyped attribute, a belongs_to with a
class_name override, and a has_many) and asserts emit_rust renders it
correctly — closing the "pull-back codegen leg unproven on Rails" gap
named in the handover's risk list. Fully offline, OGAR-only — no
openproject-nexgen-rs change.

Found and fixed a real (if narrow) bug along the way: screaming_snake()
only split on '.'/'_', so it silently produced WORKPACKAGE_CLASSID
instead of WORK_PACKAGE_CLASSID for any already-PascalCase Rails class
name (Rails class names carry no separator at all — Odoo's underscored
names happened to mask this). Fixed to also split on a lower->upper case
transition; added a direct unit test
(screaming_snake_splits_bare_pascal_case_rails_names) covering
WorkPackage/TimeEntry/Project plus the original dotted-Odoo-name case.

Verification: standalone probe workspace (same as the rest of this PR).
46/46 tests pass (2 new). clippy -D warnings clean, both --no-deps and
full workspace, at the pinned 1.95.0 toolchain. cargo fmt --check clean
for the lines this commit touches (the crate carries pre-existing,
unrelated fmt drift from never being cargo-fmt-gated — same root cause
as the clippy debt fixed earlier in this PR; left untouched, out of
scope here).

Author: claude

crates/ogar-from-ruff/src/emit.rs

@@ -323,21 +323,43 @@ fn pascal_case(name: &str) -> String {
         .collect()
 }
 
-/// `account_move` → `ACCOUNT_MOVE` (for the `*_CLASSID` const name).
+/// `account_move` → `ACCOUNT_MOVE`; `WorkPackage` → `WORK_PACKAGE` (for the
+/// `*_CLASSID` const name). Splits on `.`/`_` (Odoo's dotted/underscored
+/// names) AND on a lower→upper case transition (Rails' bare PascalCase class
+/// names carry no separator at all — `screaming_snake` must still find the
+/// word boundary, or every Rails-sourced const collapses to one run-on word
+/// like `WORKPACKAGE_CLASSID`). Does not split consecutive uppercase runs
+/// (acronyms): `HTTPServer` → `HTTPSERVER` — no Rails/Odoo class name in the
+/// corpus is acronym-prefixed, so this is a deliberately narrow rule, not a
+/// general camelCase tokenizer.
 fn screaming_snake(name: &str) -> String {
-    name.split(['.', '_'])
-        .filter(|seg| !seg.is_empty())
-        .map(str::to_uppercase)
-        .collect::<Vec<_>>()
-        .join("_")
+    let mut out = String::new();
+    let mut prev_lower = false;
+    for ch in name.chars() {
+        if ch == '.' || ch == '_' {
+            if !out.is_empty() && !out.ends_with('_') {
+                out.push('_');
+            }
+            prev_lower = false;
+            continue;
+        }
+        if ch.is_uppercase() && prev_lower {
+            out.push('_');
+        }
+        out.extend(ch.to_uppercase());
+        prev_lower = ch.is_lowercase();
+    }
+    out
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::mint::compile_graph_python;
     use ogar_vocab::ports::OdooPort;
-    use ruff_spo_triplet::{Field, Function, Model, ModelGraph};
+    use ruff_spo_triplet::{
+        AssocDecl, AssocKind, AttrDecl, AttrKind, Field, Function, Model, ModelGraph,
+    };
 
     fn account_move_graph() -> ModelGraph {
         let mut m = Model::new("account_move");
@@ -420,6 +442,79 @@ mod tests {
         assert!(rust.contains("// computed: amount_total <- _compute_amount(line_ids.balance)"));
     }
 
+    // ───── Rails (compile_graph_ruby) — the convergence proof ─────
+    //
+    // The pull-back codegen leg (emit_rust/csharp/python) was, before this
+    // session, only ever exercised on an Odoo-lifted `CompiledClass`. This
+    // fixture proves the SAME emitters run unmodified on a Rails-lifted one
+    // (compile_graph_ruby, ruff#38 + this crate's `mint::compile_graph_ruby`),
+    // closing the "unproven on Rails" gap named in the OP+Redmine convergence
+    // handover (openproject-nexgen-rs .claude/handovers/
+    // 2026-06-30-1200-op-redmine-ogar-convergence-assessment.md §4 step 2).
+
+    fn work_package_rail_graph() -> ModelGraph {
+        let mut m = Model::new("WorkPackage");
+        m.attributes.push(AttrDecl {
+            kind: AttrKind::Attribute,
+            name: "estimated_hours".to_string(),
+            options: vec![("type".to_string(), "integer".to_string())],
+        });
+        // No "type" option → the OgScalar fallback path, same as Odoo's
+        // `narration` case.
+        m.attributes.push(AttrDecl {
+            kind: AttrKind::Attribute,
+            name: "subject".to_string(),
+            options: vec![],
+        });
+        m.associations.push(AssocDecl {
+            kind: AssocKind::BelongsTo,
+            name: "project".to_string(),
+            options: vec![("class_name".to_string(), "\"Project\"".to_string())],
+        });
+        m.associations.push(AssocDecl {
+            kind: AssocKind::HasMany,
+            name: "time_entries".to_string(),
+            options: vec![],
+        });
+        let mut g = ModelGraph::new("openproject");
+        g.models.push(m);
+        g
+    }
+
+    #[test]
+    fn emits_rust_struct_for_rails_lifted_class() {
+        use crate::mint::compile_graph_ruby;
+        use ogar_vocab::ports::OpenProjectPort;
+
+        let cc = &compile_graph_ruby::<OpenProjectPort>(&work_package_rail_graph())[0];
+        let rust = emit_rust(cc);
+
+        assert!(
+            rust.contains("pub const WORK_PACKAGE_CLASSID: u32 = 0x00010102;"),
+            "got:\n{rust}"
+        ); // exercises the screaming_snake PascalCase fix below
+        assert!(rust.contains("pub struct WorkPackage {"));
+        // Rails `attribute :estimated_hours, :integer` -> OgInt (the same
+        // og_scalar_type table Odoo's `integer` constructor maps through —
+        // shared vocabulary across producers, per §1.6).
+        assert!(rust.contains("pub estimated_hours: OgInt,"), "got:\n{rust}");
+        // Untyped attribute -> OgScalar fallback.
+        assert!(rust.contains("pub subject: OgScalar,"), "got:\n{rust}");
+        // belongs_to with class_name override -> ToOne<Project>, not
+        // ToOne<Project> from the (singular) relation name by coincidence —
+        // assert the class_name path specifically by using a relation name
+        // that would pascal_case differently if class_name were ignored.
+        assert!(
+            rust.contains("pub project: ToOne<Project>,"),
+            "got:\n{rust}"
+        );
+        // has_many, no class_name -> pascal_case(time_entries) = TimeEntries.
+        assert!(
+            rust.contains("pub time_entries: ToMany<TimeEntries>,"),
+            "got:\n{rust}"
+        );
+    }
+
     #[test]
     fn emits_csharp_record_with_wrapper_contract_types() {
         let cc = &compile_graph_python::<OdooPort>(&account_move_graph())[0];
@@ -536,6 +631,19 @@ mod tests {
         assert_eq!(screaming_snake("account_move"), "ACCOUNT_MOVE");
     }
 
+    #[test]
+    fn screaming_snake_splits_bare_pascal_case_rails_names() {
+        // Rails class names carry no separator at all (no dots, no
+        // underscores) — screaming_snake must find the word boundary from
+        // case alone, or every Rails const collapses to one run-on word.
+        assert_eq!(screaming_snake("WorkPackage"), "WORK_PACKAGE");
+        assert_eq!(screaming_snake("TimeEntry"), "TIME_ENTRY");
+        // Already-snake input is unaffected (the original behaviour).
+        assert_eq!(screaming_snake("account.move.line"), "ACCOUNT_MOVE_LINE");
+        // A single PascalCase word with no internal boundary stays whole.
+        assert_eq!(screaming_snake("Project"), "PROJECT");
+    }
+
     #[test]
     fn og_scalar_type_maps_odoo_constructors() {
         assert_eq!(og_scalar_type(Some("char")), "OgStr");

crates/ogar-from-ruff/src/mint.rs

@@ -136,8 +136,8 @@ fn model_of(node: &str) -> &str {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ogar_vocab::ports::{OdooPort, OpenProjectPort, RedminePort};
     use ogar_vocab::Language;
+    use ogar_vocab::ports::{OdooPort, OpenProjectPort, RedminePort};
     use ruff_spo_triplet::{AssocDecl, AssocKind, Field, Function, Model};
 
     // A representative `account.move` `ModelGraph`, constructed directly (the
@@ -301,11 +301,7 @@ mod tests {
 
         // OpenProject prefix 0x0001 | project_work_item concept 0x0102.
         assert_eq!(cc.facet.facet_classid(), 0x0001_0102);
-        assert_eq!(
-            cc.facet.facet_classid() & 0xFFFF,
-            0x0102,
-            "shared concept"
-        );
+        assert_eq!(cc.facet.facet_classid() & 0xFFFF, 0x0102, "shared concept");
         assert_eq!(
             (cc.facet.facet_classid() >> 16) as u16,
             OpenProjectPort::APP_PREFIX,