rails-schema 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97d15de972c2e7c9c3d9e395d0b610b95806e7f6ef5729eed214f5cb7723bb61
-  data.tar.gz: 7edc0d7d8cd246ad80cc2dd54936a0c9802b662476400f095d076bed651d6472
+  metadata.gz: 37ed34e2667a948b30551666b19657a3bf6e1a484e4fe4660a3da03c9d356f66
+  data.tar.gz: c7f9ac452ae98d4188718c47879a2b1fc2769b21d308b7d07f89779c42273f95
 SHA512:
-  metadata.gz: 3ba7bf7dd2ac15538fa4a9f14b2772c4065fd6dc51a5325e1863e4d4e83838cdaa14497f5b4a4f6d7ffcdc014fe03ba9e1f3464e722ef57f73a56d14314997f0
-  data.tar.gz: f41572f08a43be003061f2e47914ed36ed27b2718b10d0d3e238c9ca436ea3230ca7e61e5213acdbf50cab6f19b96506d5d1c8d0de33bc2831e2ab84181adac0
+  metadata.gz: a21acfd8d250d9fffdd67acc95a6743167f26cf2754c4d71d35af9a74a1f450c4954eb6443fe20d8198e066f8ef8e783924ed4cab3a7b39f7f2f9006e5913af7
+  data.tar.gz: 837e5b1171e30ff17aca2e8871bed916d691203c28e8a876d92948ef38018ce23856f7263c95d96c3334c04be853b46bad48cd09101f5b7cf42da742f1db9246

data/CLAUDE.md

@@ -0,0 +1,48 @@
+# CLAUDE.md — Project Instructions for Claude Code
+
+## Project
+
+`rails-schema` — a Ruby gem that generates an interactive HTML entity-relationship diagram from a Rails app's models, associations, and columns. Single self-contained HTML output, no server needed.
+
+## Quick Commands
+
+```bash
+bundle exec rspec          # Run all tests
+bundle exec rubocop        # Run linter
+bundle exec rspec spec/rails/schema/extractor/mongoid/  # Mongoid tests only
+```
+
+## Architecture
+
+Three-layer pipeline: **Extractor → Transformer → Renderer**
+
+- `lib/rails/schema.rb` — entry point, `generate` dispatches to ActiveRecord or Mongoid pipeline
+- `lib/rails/schema/extractor/` — model discovery, column/association reading, schema file parsing
+- `lib/rails/schema/extractor/mongoid/` — Mongoid-specific extractors (model_scanner, model_adapter, column_reader, association_reader)
+- `lib/rails/schema/transformer/` — builds normalized graph JSON (nodes + edges + metadata)
+- `lib/rails/schema/renderer/` — ERB-based HTML generation with inlined JS/CSS/data
+- `lib/rails/schema/assets/` — frontend (vanilla JS + d3-force, CSS, HTML template)
+
+## Key Conventions
+
+- Ruby >= 3.2, Rails >= 6.0
+- Double quotes for strings (RuboCop enforced)
+- RuboCop max method length: 15 lines, default ABC/complexity limits
+- No `Style/Documentation` required
+- `spec/support/test_models.rb` — ActiveRecord test models (User, Post, Comment, Tag)
+- `spec/support/mongoid_test_models.rb` — Mongoid test models (MongoidUser, MongoidPost, MongoidComment)
+- Tests use in-memory SQLite for ActiveRecord, stubbed Mongoid::Document for Mongoid
+- `config.before(:each) { Rails::Schema.reset_configuration! }` in spec_helper
+
+## Schema Formats
+
+`config.schema_format` supports: `:auto`, `:ruby`, `:sql`, `:mongoid`
+
+- `:auto` — tries schema.rb, falls back to structure.sql; auto-detects Mongoid if `Mongoid::Document` is defined
+- `:mongoid` — runtime introspection of Mongoid models (no schema file needed)
+
+## Testing Notes
+
+- Always run `bundle exec rubocop` before committing — CI checks both tests and linting
+- Mongoid specs stub `Rails::Engine` and `Rails::Application` since they may not exist in test env
+- SimpleCov is enabled; coverage report goes to `coverage/`

data/PROJECT.md

@@ -43,7 +43,7 @@ Rails::Schema.generate(output: "docs/schema.html")
 
 | Layer | Responsibility | Key Classes |
 |---|---|---|
-| **Extractor** | Introspects Rails environment; collects models, columns, associations | `Rails::Schema::Extractor::ModelScanner`, `ColumnReader`, `AssociationReader`, `SchemaFileParser`, `StructureSqlParser` |
+| **Extractor** | Introspects Rails environment; collects models, columns, associations | `Rails::Schema::Extractor::ModelScanner`, `ColumnReader`, `AssociationReader`, `SchemaFileParser`, `StructureSqlParser`, plus `Mongoid::ModelScanner`, `Mongoid::ModelAdapter`, `Mongoid::ColumnReader`, `Mongoid::AssociationReader` |
 | **Transformer** | Normalizes extracted data into a serializable graph structure (nodes + edges + metadata) | `Rails::Schema::Transformer::GraphBuilder`, `Node`, `Edge` |
 | **Renderer** | Takes the graph data and injects it into an HTML/JS/CSS template using ERB | `Rails::Schema::Renderer::HtmlGenerator` |
 | **Railtie** | Provides the `rails_schema:generate` rake task | `Rails::Schema::Railtie` |
@@ -84,7 +84,7 @@ end
 
 ### 3.2 Model Discovery
 
-`ModelScanner` discovers models by:
+`ModelScanner` (ActiveRecord) discovers models by:
 
 1. Calling `Rails.application.eager_load!` (with Zeitwerk support and multiple fallback strategies)
 2. Collecting `ActiveRecord::Base.descendants`
@@ -94,6 +94,14 @@ end
 
 When `schema_data` is available, table existence is checked against parsed schema data instead of hitting the database.
 
+`Mongoid::ModelScanner` discovers Mongoid models by:
+
+1. Eager-loading models via Zeitwerk or file glob (with fallback strategies)
+2. Scanning `ObjectSpace` for classes that include `Mongoid::Document`
+3. Also eager-loads models from mounted Rails engines
+4. Applying `exclude_models` configuration
+5. Returning models sorted by name, wrapped in `ModelAdapter` for GraphBuilder compatibility
+
 ### 3.3 Schema File Parser
 
 `SchemaFileParser` provides database-free column extraction:
@@ -218,7 +226,7 @@ Rails::Schema.configure do |config|
   config.title          = "Database Schema"      # Page title
   config.theme          = :auto                  # :light, :dark, :auto
   config.expand_columns = false                  # Start with columns expanded
-  config.schema_format  = :auto                  # :auto, :ruby, or :sql
+  config.schema_format  = :auto                  # :auto, :ruby, :sql, or :mongoid
 end
 ```
 
@@ -239,7 +247,12 @@ rails-schema/
 │       │   ├── association_reader.rb      # Reads reflections
 │       │   ├── column_reader.rb           # Reads columns (schema_data or AR)
 │       │   ├── schema_file_parser.rb      # Parses db/schema.rb
-│       │   └── structure_sql_parser.rb   # Parses db/structure.sql
+│       │   ├── structure_sql_parser.rb   # Parses db/structure.sql
+│       │   └── mongoid/
+│       │       ├── model_scanner.rb      # Discovers Mongoid models
+│       │       ├── model_adapter.rb      # Wraps Mongoid model for GraphBuilder
+│       │       ├── column_reader.rb      # Reads Mongoid fields
+│       │       └── association_reader.rb # Reads Mongoid relations
 │       ├── transformer/
 │       │   ├── graph_builder.rb           # Builds node/edge graph
 │       │   ├── node.rb                    # Value object
@@ -255,7 +268,8 @@ rails-schema/
 ├── spec/
 │   ├── spec_helper.rb
 │   ├── support/
-│   │   └── test_models.rb                # User, Post, Comment, Tag models
+│   │   ├── test_models.rb                # User, Post, Comment, Tag AR models
+│   │   └── mongoid_test_models.rb       # MongoidUser, MongoidPost, MongoidComment
 │   └── rails/schema/
 │       ├── rails_schema_spec.rb
 │       ├── configuration_spec.rb
@@ -264,7 +278,12 @@ rails-schema/
 │       │   ├── column_reader_spec.rb
 │       │   ├── association_reader_spec.rb
 │       │   ├── schema_file_parser_spec.rb
-│       │   └── structure_sql_parser_spec.rb
+│       │   ├── structure_sql_parser_spec.rb
+│       │   └── mongoid/
+│       │       ├── model_scanner_spec.rb
+│       │       ├── model_adapter_spec.rb
+│       │       ├── column_reader_spec.rb
+│       │       └── association_reader_spec.rb
 │       ├── transformer/
 │       │   └── graph_builder_spec.rb
 │       └── renderer/
@@ -323,7 +342,7 @@ spec.add_dependency "railties", ">= 6.0"
 | Renderer | Output tests — verify HTML structure, embedded data, script injection safety |
 | Configuration | Unit tests for defaults and attribute setting |
 
-**108 tests, all passing.** Run with `bundle exec rspec`.
+**153 tests, all passing.** Run with `bundle exec rspec`.
 
 ---
 

data/README.md

@@ -48,7 +48,7 @@ Rails::Schema.configure do |config|
   config.title = "My App Schema"
   config.theme = :auto          # :auto, :light, or :dark
   config.expand_columns = false # start with columns collapsed
-  config.schema_format = :auto  # :auto, :ruby, or :sql
+  config.schema_format = :auto  # :auto, :ruby, :sql, or :mongoid
   config.exclude_models = [
     "ActiveStorage::Blob",
     "ActiveStorage::Attachment",
@@ -63,7 +63,7 @@ end
 | `title` | `"Database Schema"` | Title shown in the HTML page |
 | `theme` | `:auto` | Color theme — `:auto`, `:light`, or `:dark` |
 | `expand_columns` | `false` | Whether model nodes start with columns expanded |
-| `schema_format` | `:auto` | Schema source — `:auto`, `:ruby`, or `:sql` (see below) |
+| `schema_format` | `:auto` | Schema source — `:auto`, `:ruby`, `:sql`, or `:mongoid` (see below) |
 | `exclude_models` | `[]` | Models to hide; supports exact names and wildcard prefixes (`"ActionMailbox::*"`) |
 
 ### Schema format
@@ -72,17 +72,34 @@ Rails projects can use either `db/schema.rb` (Ruby DSL) or `db/structure.sql` (r
 
 | Value | Behavior |
 |-------|----------|
-| `:auto` | Tries `db/schema.rb` first, falls back to `db/structure.sql` |
+| `:auto` | Tries `db/schema.rb` first, falls back to `db/structure.sql`. If Mongoid is detected, uses the Mongoid pipeline instead |
 | `:ruby` | Only reads `db/schema.rb` |
 | `:sql` | Only reads `db/structure.sql` |
+| `:mongoid` | Introspects Mongoid models directly (see below) |
+
+### Mongoid support
+
+If your app uses [Mongoid](https://www.mongodb.com/docs/mongoid/current/) instead of ActiveRecord, rails-schema can introspect your Mongoid models directly — no schema file needed.
+
+```ruby
+Rails::Schema.configure do |config|
+  config.schema_format = :mongoid
+end
+```
+
+When set to `:auto`, Mongoid mode activates automatically if `Mongoid::Document` is defined.
+
+The Mongoid pipeline reads fields, types, defaults, and presence validations from your models, and discovers all association types including `embeds_many`, `embeds_one`, `embedded_in`, and `has_and_belongs_to_many`.
 
 ## How it works
 
 The gem parses your `db/schema.rb` or `db/structure.sql` file to extract table and column information — **no database connection required**. It also introspects loaded ActiveRecord models for association metadata. This means the gem works even if you don't have a local database set up, as long as a schema file is present (which is standard in Rails projects under version control).
 
+For Mongoid apps, the gem introspects model classes at runtime to read field definitions, associations, and validations — no schema file or database connection required.
+
 ## Features
 
-- **No database required** — reads from `db/schema.rb` or `db/structure.sql`
+- **No database required** — reads from `db/schema.rb`, `db/structure.sql`, or Mongoid model introspection
 - **Force-directed layout** — models cluster naturally by association density
 - **Searchable sidebar** — filter models by name or table
 - **Click-to-focus** — click a model to highlight its neighborhood, fading unrelated models

data/lib/rails/schema/assets/app.js

@@ -6,6 +6,15 @@
   var nodes = data.nodes;
   var edges = data.edges;
 
+  // Hide legend items that don't apply to the current schema mode
+  var mode = data.metadata && data.metadata.mode;
+  if (mode) {
+    var hideMode = mode === "mongoid" ? "active_record" : "mongoid";
+    document.querySelectorAll('.legend-item[data-mode="' + hideMode + '"]').forEach(function(el) {
+      el.style.display = "none";
+    });
+  }
+
   // State
   var selectedNode = null;
   var visibleModels = new Set(nodes.map(function(n) { return n.id; }));
@@ -35,7 +44,10 @@
     belongs_to: "--edge-belongs-to",
     has_many: "--edge-has-many",
     has_one: "--edge-has-one",
-    has_and_belongs_to_many: "--edge-habtm"
+    has_and_belongs_to_many: "--edge-habtm",
+    embeds_many: "--edge-embeds-many",
+    embeds_one: "--edge-embeds-one",
+    embedded_in: "--edge-embedded-in"
   };
 
   function buildMarkers() {
@@ -113,7 +125,10 @@
     belongs_to:              { start: "many", end: "one" },
     has_many:                { start: "one",  end: "many" },
     has_one:                 { start: "one",  end: "one" },
-    has_and_belongs_to_many: { start: "many", end: "many" }
+    has_and_belongs_to_many: { start: "many", end: "many" },
+    embeds_many:             { start: "one",  end: "many" },
+    embeds_one:              { start: "one",  end: "one" },
+    embedded_in:             { start: "many", end: "one" }
   };
 
   function getColumnY(node, colName) {
@@ -142,10 +157,11 @@
     var srcColY = 0;
     var tgtColY = 0;
 
-    if (assocType === "belongs_to") {
+    if (assocType === "belongs_to" || assocType === "embedded_in") {
       srcColY = getColumnY(src, fk);
       tgtColY = getPkColumnY(tgt);
-    } else if (assocType === "has_many" || assocType === "has_one") {
+    } else if (assocType === "has_many" || assocType === "has_one" ||
+               assocType === "embeds_many" || assocType === "embeds_one") {
       srcColY = getPkColumnY(src);
       tgtColY = getColumnY(tgt, fk);
     } else {
@@ -251,6 +267,9 @@
         return m ? "url(#marker-" + m.end + "-" + d.data.association_type + ")" : null;
       });
 
+    eGroups.append("rect")
+      .attr("class", "edge-label-bg");
+
     eGroups.append("text")
       .attr("class", "edge-label")
       .attr("text-anchor", "middle")
@@ -414,10 +433,59 @@
         .attr("y", labelY);
     });
 
+    resolveEdgeLabelOverlaps();
+
     nodeGroup.selectAll(".node-group")
       .attr("transform", function(d) { return "translate(" + d.x + "," + d.y + ")"; });
   }
 
+  function resolveEdgeLabelOverlaps() {
+    var labels = [];
+    edgeGroup.selectAll(".edge-group text").each(function() {
+      var el = d3.select(this);
+      var x = +el.attr("x");
+      var y = +el.attr("y");
+      var text = el.text();
+      var w = text.length * 6;  // approximate width at 10px font
+      var h = 14;               // approximate height
+      labels.push({ el: el, x: x, y: y, w: w, h: h });
+    });
+
+    // Run a few nudge passes
+    for (var pass = 0; pass < 3; pass++) {
+      for (var i = 0; i < labels.length; i++) {
+        for (var j = i + 1; j < labels.length; j++) {
+          var a = labels[i], b = labels[j];
+          var overlapX = (a.w + b.w) / 2 - Math.abs(a.x - b.x);
+          var overlapY = (a.h + b.h) / 2 - Math.abs(a.y - b.y);
+          if (overlapX > 0 && overlapY > 0) {
+            // Push apart vertically
+            var shift = (overlapY / 2) + 2;
+            if (a.y <= b.y) {
+              a.y -= shift;
+              b.y += shift;
+            } else {
+              a.y += shift;
+              b.y -= shift;
+            }
+          }
+        }
+      }
+    }
+
+    // Apply resolved positions and update background rects
+    labels.forEach(function(l) {
+      l.el.attr("y", l.y);
+      var bg = d3.select(l.el.node().previousElementSibling);
+      if (bg.classed("edge-label-bg")) {
+        bg.attr("x", l.x - l.w / 2)
+          .attr("y", l.y - l.h + 2)
+          .attr("width", l.w)
+          .attr("height", l.h);
+      }
+    });
+  }
+
   // Drag behavior
   function dragStarted(event, d) {
     if (!event.active) simulation.alphaTarget(0.3).restart();

data/lib/rails/schema/assets/style.css

@@ -17,6 +17,9 @@
   --edge-has-many: #2ec4b6;
   --edge-has-one: #ff6b6b;
   --edge-habtm: #ffd166;
+  --edge-embeds-many: #a855f7;
+  --edge-embeds-one: #c084fc;
+  --edge-embedded-in: #a855f7;
   --shadow: 0 2px 8px rgba(0,0,0,0.1);
   --sidebar-width: 280px;
   --detail-width: 320px;
@@ -42,6 +45,9 @@
   --edge-has-many: #2ec4b6;
   --edge-has-one: #ff6b6b;
   --edge-habtm: #ffd166;
+  --edge-embeds-many: #a855f7;
+  --edge-embeds-one: #c084fc;
+  --edge-embedded-in: #a855f7;
   --shadow: 0 2px 8px rgba(0,0,0,0.3);
 }
 
@@ -65,6 +71,9 @@
     --edge-has-many: #2ec4b6;
     --edge-has-one: #ff6b6b;
     --edge-habtm: #ffd166;
+    --edge-embeds-many: #a855f7;
+    --edge-embeds-one: #c084fc;
+    --edge-embedded-in: #a855f7;
     --shadow: 0 2px 8px rgba(0,0,0,0.3);
   }
 }
@@ -318,6 +327,9 @@ body {
 .edge-line.has_many { stroke: var(--edge-has-many); }
 .edge-line.has_one { stroke: var(--edge-has-one); }
 .edge-line.has_and_belongs_to_many { stroke: var(--edge-habtm); }
+.edge-line.embeds_many { stroke: var(--edge-embeds-many); stroke-dasharray: 4 2; }
+.edge-line.embeds_one { stroke: var(--edge-embeds-one); stroke-dasharray: 4 2; }
+.edge-line.embedded_in { stroke: var(--edge-embedded-in); stroke-dasharray: 4 2; }
 
 .edge-line.through {
   stroke-dasharray: 6 3;
@@ -334,6 +346,13 @@ body {
   pointer-events: none;
 }
 
+.edge-label-bg {
+  fill: var(--bg-primary);
+  opacity: 0.85;
+  rx: 2;
+  pointer-events: none;
+}
+
 /* Faded state for non-focused elements */
 .faded { opacity: 0.15; transition: opacity 0.3s; }
 .highlighted { transition: opacity 0.3s; }
@@ -473,6 +492,22 @@ body {
 .legend-line.has_many { background: var(--edge-has-many); }
 .legend-line.has_one { background: var(--edge-has-one); }
 .legend-line.habtm { background: var(--edge-habtm); }
+.legend-line.embeds_many {
+  background-image: repeating-linear-gradient(
+    to right,
+    var(--edge-embeds-many) 0, var(--edge-embeds-many) 4px,
+    transparent 4px, transparent 6px
+  );
+  background-color: transparent;
+}
+.legend-line.embeds_one {
+  background-image: repeating-linear-gradient(
+    to right,
+    var(--edge-embeds-one) 0, var(--edge-embeds-one) 4px,
+    transparent 4px, transparent 6px
+  );
+  background-color: transparent;
+}
 
 .legend-line.through {
   background: var(--edge-color);

data/lib/rails/schema/assets/template.html.erb

@@ -26,7 +26,9 @@
         <span class="legend-item"><span class="legend-line has_many"></span> has_many (1:M)</span>
         <span class="legend-item"><span class="legend-line has_one"></span> has_one (1:1)</span>
         <span class="legend-item"><span class="legend-line habtm"></span> habtm (M:M)</span>
-        <span class="legend-item"><span class="legend-line through"></span> :through</span>
+        <span class="legend-item" data-mode="mongoid"><span class="legend-line embeds_many"></span> embeds_many</span>
+        <span class="legend-item" data-mode="mongoid"><span class="legend-line embeds_one"></span> embeds_one</span>
+        <span class="legend-item" data-mode="active_record"><span class="legend-line through"></span> :through</span>
         <span class="legend-item"><span class="legend-line polymorphic"></span> polymorphic</span>
       </div>
       <div class="spacer"></div>

data/lib/rails/schema/extractor/mongoid/association_reader.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Rails
+  module Schema
+    module Extractor
+      module Mongoid
+        class AssociationReader
+          ASSOCIATION_TYPE_MAP = {
+            "Mongoid::Association::Referenced::HasMany" => "has_many",
+            "Mongoid::Association::Referenced::HasOne" => "has_one",
+            "Mongoid::Association::Referenced::BelongsTo" => "belongs_to",
+            "Mongoid::Association::Referenced::HasAndBelongsToMany" => "has_and_belongs_to_many",
+            "Mongoid::Association::Embedded::EmbedsMany" => "embeds_many",
+            "Mongoid::Association::Embedded::EmbedsOne" => "embeds_one",
+            "Mongoid::Association::Embedded::EmbeddedIn" => "embedded_in"
+          }.freeze
+
+          def read(model)
+            model.relations.filter_map do |name, metadata|
+              next if skip_association?(metadata)
+
+              build_association_data(model, name, metadata)
+            end
+          rescue StandardError => e
+            warn "[rails-schema] Could not read Mongoid relations for #{model.name}: #{e.class}: #{e.message}"
+            []
+          end
+
+          private
+
+          def skip_association?(metadata)
+            association_type_string(metadata) == "belongs_to" && metadata.polymorphic?
+          end
+
+          def build_association_data(model, name, metadata)
+            {
+              from: model.name,
+              to: metadata.class_name,
+              association_type: association_type_string(metadata),
+              label: name.to_s,
+              foreign_key: metadata.respond_to?(:foreign_key) ? metadata.foreign_key&.to_s : nil,
+              through: nil,
+              polymorphic: metadata.respond_to?(:as) && metadata.as ? true : false
+            }
+          rescue StandardError => e
+            warn "[rails-schema] Could not read Mongoid association #{name} on #{model.name}: " \
+                 "#{e.class}: #{e.message}"
+            nil
+          end
+
+          def association_type_string(metadata)
+            # metadata.class returns the association class (e.g. Mongoid::Association::Referenced::HasMany)
+            ASSOCIATION_TYPE_MAP.fetch(metadata.class.name, metadata.class.name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/schema/extractor/mongoid/column_reader.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rails
+  module Schema
+    module Extractor
+      module Mongoid
+        class ColumnReader
+          TYPE_MAP = {
+            "String" => "string",
+            "Integer" => "integer",
+            "Float" => "float",
+            "BigDecimal" => "decimal",
+            "Date" => "date",
+            "Time" => "datetime",
+            "DateTime" => "datetime",
+            "Array" => "array",
+            "Hash" => "hash",
+            "Regexp" => "regexp",
+            "Symbol" => "symbol",
+            "Range" => "range",
+            "BSON::ObjectId" => "object_id",
+            "Mongoid::Boolean" => "boolean",
+            "TrueClass" => "boolean",
+            "FalseClass" => "boolean"
+          }.freeze
+
+          def read(model)
+            model.fields.map do |name, field|
+              {
+                name: name,
+                type: map_type(field.type),
+                nullable: !required_field?(model, name),
+                primary: name == "_id",
+                default: format_default(field.default_val)
+              }
+            end
+          rescue StandardError => e
+            warn "[rails-schema] Could not read Mongoid fields for #{model.name}: #{e.class}: #{e.message}"
+            []
+          end
+
+          private
+
+          def required_field?(model, field_name)
+            return true if field_name == "_id"
+            return false unless model.respond_to?(:validators_on)
+
+            model.validators_on(field_name).any? do |v|
+              v.class.name.include?("PresenceValidator")
+            end
+          end
+
+          def map_type(type)
+            return "object" if type.nil?
+
+            TYPE_MAP.fetch(type.name, type.name.downcase)
+          end
+
+          def format_default(default)
+            case default
+            when Proc
+              "(dynamic)"
+            else
+              default
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/schema/extractor/mongoid/model_adapter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rails
+  module Schema
+    module Extractor
+      module Mongoid
+        class ModelAdapter
+          attr_reader :model
+
+          def initialize(model)
+            @model = model
+          end
+
+          def name
+            model.name
+          end
+
+          def table_name
+            model.collection_name.to_s
+          end
+
+          def respond_to_missing?(method, include_private = false)
+            model.respond_to?(method, include_private) || super
+          end
+
+          def method_missing(method, ...)
+            if model.respond_to?(method)
+              model.send(method, ...)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/schema/extractor/mongoid/model_scanner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Rails
+  module Schema
+    module Extractor
+      module Mongoid
+        class ModelScanner
+          def initialize(configuration: ::Rails::Schema.configuration)
+            @configuration = configuration
+          end
+
+          def scan
+            eager_load_models!
+
+            candidates = ObjectSpace.each_object(Class).select do |klass|
+              klass.include?(::Mongoid::Document)
+            rescue StandardError
+              false
+            end
+
+            named = candidates.reject { |m| m.name.nil? }
+            included = named.reject { |m| excluded?(m) }
+
+            included.sort_by(&:name)
+          end
+
+          private
+
+          def eager_load_models!
+            return unless defined?(::Rails.application) && ::Rails.application
+
+            if zeitwerk_available?
+              eager_load_via_zeitwerk!
+            else
+              eager_load_via_application!
+            end
+
+            eager_load_engine_models!
+          end
+
+          def eager_load_via_zeitwerk!
+            loader = ::Rails.autoloaders.main
+            models_path = ::Rails.root&.join("app", "models")&.to_s
+
+            if models_path && File.directory?(models_path) && loader.respond_to?(:eager_load_dir)
+              loader.eager_load_dir(models_path)
+            else
+              loader.eager_load
+            end
+          rescue StandardError => e
+            warn "[rails-schema] Zeitwerk eager_load failed (#{e.class}: #{e.message}), " \
+                 "trying Rails.application.eager_load!"
+            eager_load_via_application!
+          end
+
+          def eager_load_via_application!
+            ::Rails.application.eager_load!
+          rescue StandardError => e
+            warn "[rails-schema] eager_load! failed (#{e.class}: #{e.message}), " \
+                 "falling back to per-file model loading"
+            eager_load_model_files!
+          end
+
+          def eager_load_model_files!
+            return unless defined?(::Rails.root) && ::Rails.root
+
+            models_path = ::Rails.root.join("app", "models")
+            return unless models_path.exist?
+
+            Dir.glob(models_path.join("**/*.rb")).each do |file|
+              require file
+            rescue StandardError => e
+              warn "[rails-schema] Could not load #{file}: #{e.class}: #{e.message}"
+            end
+          end
+
+          def eager_load_engine_models!
+            return unless defined?(::Rails::Engine)
+
+            ::Rails::Engine.subclasses.each do |engine_class|
+              next if engine_class <= ::Rails::Application
+
+              engine = engine_class.instance
+              next unless engine
+
+              eager_load_engine(engine)
+            rescue StandardError => e
+              warn "[rails-schema] Could not eager-load engine #{engine_class}: #{e.class}: #{e.message}"
+            end
+          end
+
+          def eager_load_engine(engine)
+            models_paths = engine.paths["app/models"]&.existent || []
+            return if models_paths.empty?
+
+            if zeitwerk_available?
+              eager_load_engine_zeitwerk(models_paths)
+            else
+              eager_load_engine_files(models_paths)
+            end
+          end
+
+          def zeitwerk_available?
+            defined?(::Rails.autoloaders) && ::Rails.autoloaders.respond_to?(:main)
+          end
+
+          def eager_load_engine_zeitwerk(paths)
+            loader = ::Rails.autoloaders.main
+            paths.each { |path| loader.eager_load_dir(path) if loader.respond_to?(:eager_load_dir) }
+          end
+
+          def eager_load_engine_files(paths)
+            paths.each do |path|
+              Dir.glob(File.join(path, "**/*.rb")).each do |file|
+                require file
+              rescue StandardError => e
+                warn "[rails-schema] Could not load engine model #{file}: #{e.class}: #{e.message}"
+              end
+            end
+          end
+
+          def excluded?(model)
+            @configuration.exclude_models.any? do |pattern|
+              if pattern.end_with?("*")
+                model.name.start_with?(pattern.delete_suffix("*"))
+              else
+                model.name == pattern
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Rails
   module Schema
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/rails/schema.rb

@@ -30,15 +30,58 @@ module Rails
       end
 
       def generate(output: nil)
+        if mongoid_mode?
+          generate_mongoid(output: output)
+        else
+          generate_active_record(output: output)
+        end
+      end
+
+      def mongoid_mode?
+        case configuration.schema_format
+        when :mongoid
+          true
+        when :auto
+          defined?(::Mongoid::Document) ? true : false
+        else
+          false
+        end
+      end
+
+      private
+
+      def generate_active_record(output:)
         schema_data = parse_schema
         models = Extractor::ModelScanner.new(schema_data: schema_data).scan
         column_reader = Extractor::ColumnReader.new(schema_data: schema_data)
         graph_data = Transformer::GraphBuilder.new(column_reader: column_reader).build(models)
+        graph_data[:metadata][:mode] = "active_record"
         generator = Renderer::HtmlGenerator.new(graph_data: graph_data)
         generator.render_to_file(output)
       end
 
-      private
+      def require_mongoid_extractors
+        require_relative "schema/extractor/mongoid/model_scanner"
+        require_relative "schema/extractor/mongoid/model_adapter"
+        require_relative "schema/extractor/mongoid/column_reader"
+        require_relative "schema/extractor/mongoid/association_reader"
+      end
+
+      def generate_mongoid(output:)
+        require_mongoid_extractors
+
+        raw_models = Extractor::Mongoid::ModelScanner.new.scan
+        models = raw_models.map { |m| Extractor::Mongoid::ModelAdapter.new(m) }
+        column_reader = Extractor::Mongoid::ColumnReader.new
+        association_reader = Extractor::Mongoid::AssociationReader.new
+        graph_data = Transformer::GraphBuilder.new(
+          column_reader: column_reader,
+          association_reader: association_reader
+        ).build(models)
+        graph_data[:metadata][:mode] = "mongoid"
+        generator = Renderer::HtmlGenerator.new(graph_data: graph_data)
+        generator.render_to_file(output)
+      end
 
       def parse_schema
         case configuration.schema_format

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrei Kislichenko
@@ -46,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - PROJECT.md
 - README.md
@@ -61,6 +62,10 @@ files:
 - lib/rails/schema/extractor/association_reader.rb
 - lib/rails/schema/extractor/column_reader.rb
 - lib/rails/schema/extractor/model_scanner.rb
+- lib/rails/schema/extractor/mongoid/association_reader.rb
+- lib/rails/schema/extractor/mongoid/column_reader.rb
+- lib/rails/schema/extractor/mongoid/model_adapter.rb
+- lib/rails/schema/extractor/mongoid/model_scanner.rb
 - lib/rails/schema/extractor/schema_file_parser.rb
 - lib/rails/schema/extractor/structure_sql_parser.rb
 - lib/rails/schema/railtie.rb