feat: add ogar-from-ruff + ogar-from-rails — producer-side bridge for the Rails ecosystem

The OGAR vocab was deliberately shaped to mirror ruff_ruby_spo's
C17a–c stable IR (per ogar-vocab/src/lib.rs:14: "the existing
producer can be lifted in-place"), but the lifter itself didn't
exist — OGAR had ogar-from-elixir for HIRO/Bardioc but no
ruff/Rails equivalent. This PR adds the pair.

**ogar-from-ruff** (lower-level): pure projection from
ruff_spo_triplet::Model → ogar_vocab::Class. No I/O. The IR
shapes already align field-for-field, so this is mostly
mechanical:

  name              → name
  sti.inherits_from → parent
  associations      → associations (with rich option parsing:
                      class_name / foreign_key / polymorphic /
                      through / source / as / dependent / etc.
                      AcceptsNestedAttributesFor skipped — it's a
                      UI form helper, not a relation)
  validations       → validations (Normalizes skipped — write-time
                      transform, not a constraint)
  callbacks         → callbacks (phase → event)
  concerns          → mixins (block markers skipped)
  acts_as           → mixins (as `acts_as_<variant>` prefix)
  attributes        → attributes (alias/undef/store_accessor
                      filtered; the `"type"` option lifts to
                      Attribute.type_name)
  scopes            → scopes / default_scope (split by kind)

Long-tail ruff slots (delegations / dsl_calls / gem_dsl /
dynamic_methods / refinements) pass through unfiltered today —
OGAR doesn't model them at the Class level; can land as
ogar-extensions/rails/* later.

`strip_ruby_literal_markers` normalises the verbatim option
values walk::format_hash_inline produces — strings get
unquoted (`"User"` → `User`), symbols lose the leading colon
(`:destroy` → `destroy`), bare consts pass through.

**ogar-from-rails** (high-level wrapper): walks a Rails source
tree via ruff_ruby_spo::extract, then runs each Model through
ogar-from-ruff. Output is Vec<Class>, registry-ready (handing
off to lance-graph-ontology::OntologyRegistry is a separate
follow-up — this crate's surface ends at Class).

  extract(&Path) → Vec<Class>

Mirrors the role ogar-from-elixir plays for HIRO. ogar-from-elixir
is added to workspace members in the same PR (pre-existing
oversight — it lived in crates/ but wasn't built).

**Smoke-tested on live OpenProject**: 694 Class values from
/home/user/openproject, matching ruff_ruby_spo::extract's count
1:1. WorkPackage shows up with its associations / mixins /
callbacks lifted correctly.

Tests: 9 unit tests in ogar-from-ruff (field-by-field), 1
default + 1 ignored real-corpus smoke in ogar-from-rails.

Author: claude

Cargo.toml

@@ -10,6 +10,9 @@ members = [
     "crates/ogar-adapter-ttl",
     "crates/ogar-adapter-clickhouse-ddl",
     "crates/ogar-knowable-from",
+    "crates/ogar-from-elixir",
+    "crates/ogar-from-ruff",
+    "crates/ogar-from-rails",
 ]
 
 [workspace.package]

crates/ogar-from-rails/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "ogar-from-rails"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
+rust-version.workspace = true
+description = "Rails / ActiveRecord frontend for OGAR. Walks an app/models tree via `ruff_ruby_spo::extract` then lifts the resulting `ruff_spo_triplet::ModelGraph` to `Vec<ogar_vocab::Class>` via `ogar-from-ruff::lift_model_graph`. The pair (`ogar-from-ruff` + `ogar-from-rails`) is the producer-side bridge into OGAR for the Rails ecosystem — mirrors the role `ogar-from-elixir` plays for HIRO."
+
+[features]
+default = []
+serde = [
+    "dep:serde",
+    "ogar-vocab/serde",
+    "ogar-from-ruff/serde",
+]
+
+[dependencies]
+ogar-vocab = { path = "../ogar-vocab" }
+ogar-from-ruff = { path = "../ogar-from-ruff" }
+ruff_ruby_spo = { git = "https://github.com/AdaWorldAPI/ruff", branch = "main" }
+serde = { workspace = true, optional = true }

crates/ogar-from-rails/src/lib.rs

@@ -0,0 +1,114 @@
+//! `ogar-from-rails` — Rails / ActiveRecord frontend for OGAR.
+//!
+//! Walks an `app/models/` tree via [`ruff_ruby_spo::extract`], then
+//! lifts the resulting [`ruff_spo_triplet::ir::ModelGraph`] to a
+//! `Vec<ogar_vocab::Class>` via [`ogar_from_ruff::lift_model_graph`].
+//! Mirrors the role [`ogar_from_elixir`] plays for the HIRO/Bardioc
+//! Elixir stack.
+//!
+//! ```text
+//!   app/models/      ruff_ruby_spo::extract        ogar_from_ruff::lift_model_graph
+//!     ─────────  ─────────────────────────────  ──────────────────────────────────
+//!     *.rb files →  ruff_spo_triplet::ModelGraph  →  Vec<ogar_vocab::Class>
+//!                                                              │
+//!                                                              ▼
+//!                                            lance-graph-ontology::OntologyRegistry
+//! ```
+//!
+//! # OpenProject coverage (the canonical Rails corpus)
+//!
+//! On the live OpenProject source tree at `/home/user/openproject`:
+//!
+//! ```text
+//!   $ extract(Path::new("/home/user/openproject"))
+//!   → 694 Class values
+//! ```
+//!
+//! Matches the count from `ruff_ruby_spo::extract` 1:1 — every Rails
+//! class becomes one OGAR class.
+//!
+//! # What this crate is NOT
+//!
+//! - Not a producer of `field_type` / `validation_param` / etc. SPO
+//!   triples. Those live on `ruff_spo_triplet::expand` and feed the
+//!   narrow / schema-codegen arm (`op-surreal-ast::from_triples` →
+//!   SurrealQL DDL). This crate is the **wide / OGAR vocab** arm —
+//!   they're the two sides of the §10.1 OPENPROJECT-TRANSCODING
+//!   pattern.
+//! - Not a `db/schema.rb` parser. DB-column lift is a separate
+//!   sprint; see [`ogar_from_ruff`]'s field-map table for what's
+//!   covered today.
+
+#![forbid(unsafe_code)]
+#![warn(missing_docs)]
+
+use std::path::Path;
+
+use ogar_vocab::Class;
+
+/// Top-level entry: extract from a Rails source tree to a list of
+/// OGAR `Class` values.
+///
+/// `source_tree` should be the Rails app root (the directory containing
+/// `app/`), not `app/models` itself. Matches the convention of
+/// [`ruff_ruby_spo::extract`]: it appends `app/models` internally.
+///
+/// Empty result on a tree without `app/models`, mirroring the
+/// `ruff_ruby_spo` behaviour (no errors, just zero models).
+#[must_use]
+pub fn extract(source_tree: &Path) -> Vec<Class> {
+    let graph = ruff_ruby_spo::extract(source_tree);
+    ogar_from_ruff::lift_model_graph(&graph)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    /// Empty / nonexistent source tree → empty Vec, never panics. The
+    /// `ruff_ruby_spo` contract is "no app/models → empty graph"; this
+    /// test pins that our lift preserves the no-panic behaviour.
+    #[test]
+    fn nonexistent_source_tree_yields_empty_vec() {
+        let classes = extract(Path::new("/tmp/__definitely_does_not_exist_for_test__"));
+        assert!(classes.is_empty(), "no app/models → no classes");
+    }
+
+    /// Smoke test against the live OpenProject source tree on the dev
+    /// image (when present). Gated behind `#[ignore]` so CI without
+    /// the OP checkout doesn't fail; locally `cargo test -- --ignored`
+    /// surfaces the real-corpus number.
+    #[test]
+    #[ignore = "requires /home/user/openproject Rails source"]
+    fn op_source_tree_yields_expected_class_count() {
+        let path = PathBuf::from("/home/user/openproject");
+        if !path.exists() {
+            eprintln!("skipping: {} not present", path.display());
+            return;
+        }
+        let classes = extract(&path);
+        assert!(
+            classes.len() > 500,
+            "expected ~700 classes from OP, got {}",
+            classes.len(),
+        );
+        // Sanity: at least one well-known class is in the list.
+        assert!(
+            classes.iter().any(|c| c.name == "WorkPackage"),
+            "WorkPackage must be in the lifted Classes",
+        );
+        // STI: any class with `self.inheritance_column = ...` or
+        // `abstract_class = true` carries a `parent` slot. OpenProject's
+        // WorkPackage extends ApplicationRecord (no STI), so we just
+        // check the field is exposed at all — populated for some class
+        // somewhere on the corpus (or empty if no STI exists today;
+        // this assertion is loose-by-design until the producer emits
+        // STI for the non-default-parent cases).
+        let any_parent_set = classes.iter().any(|c| c.parent.is_some());
+        // Don't hard-assert any_parent_set: OP today doesn't define
+        // STI via the explicit Rails idiom. Just verify the slot is
+        // reachable by accessing it.
+        let _ = any_parent_set;
+    }
+}

crates/ogar-from-ruff/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "ogar-from-ruff"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
+rust-version.workspace = true
+description = "Lift `ruff_spo_triplet::Model` (the language-agnostic IR populated by ruff frontends like `ruff_ruby_spo`) into `ogar_vocab::Class`. Mechanical field-by-field projection — the ruff IR was deliberately shaped to mirror ogar-vocab. This crate is the producer-side seam between ruff's parser ecosystem and OGAR's canonical vocab; thin enough to also serve as the reference implementation for other `ogar-from-<lang>` crates that go through ruff."
+
+[features]
+default = []
+serde = ["dep:serde", "ogar-vocab/serde"]
+
+[dependencies]
+ogar-vocab = { path = "../ogar-vocab" }
+ruff_spo_triplet = { git = "https://github.com/AdaWorldAPI/ruff", branch = "main" }
+serde = { workspace = true, optional = true }