rails-schema 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ed18d27750908c4973c29dd17904a623b056b9636f7a61da0a15d710575327b
-  data.tar.gz: 88f5fe0cb1c8bc618f138afaf11792733324bdca5a27bbc21ae179f83277e173
+  metadata.gz: 37ed34e2667a948b30551666b19657a3bf6e1a484e4fe4660a3da03c9d356f66
+  data.tar.gz: c7f9ac452ae98d4188718c47879a2b1fc2769b21d308b7d07f89779c42273f95
 SHA512:
-  metadata.gz: a5c174cade562f7b8026c4410fd2034a82fe325936ac32770e3604e7f3e68cea63f23364e48f929574993d3f7cf26f916b89c380459ae53537f81b39efd406c6
-  data.tar.gz: 9cc8c949efa541ffe58d0227c3ec0ae540529518bed58993530ea6890d41f5a43a0e6bda3533db7862e8cc2c0da6acaead494686f1f8f111623ab6f7fc873658
+  metadata.gz: a21acfd8d250d9fffdd67acc95a6743167f26cf2754c4d71d35af9a74a1f450c4954eb6443fe20d8198e066f8ef8e783924ed4cab3a7b39f7f2f9006e5913af7
+  data.tar.gz: 837e5b1171e30ff17aca2e8871bed916d691203c28e8a876d92948ef38018ce23856f7263c95d96c3334c04be853b46bad48cd09101f5b7cf42da742f1db9246

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.1.2] - 2026-02-22
+
+### Added
+
+- `StructureSqlParser` for extracting schema from `db/structure.sql` files
+- `schema_format` configuration option (`:ruby`, `:sql`, `:auto`)
+- `warn` messages to all silent rescue blocks in `AssociationReader` and `ColumnReader`
+
+## [0.1.1] - 2026-02-17
+
+### Added
+
+- ERD-style connections with crow's foot notation, directional indicators, and column-level attachment points
+
+### Changed
+
+- Refactored edge routing with cubic Bezier curves and improved self-referential association handling
+
+## [0.1.0] - 2026-02-15
+
+### Added
+
+- Initial release
+- Interactive HTML visualization of Rails database schema (force-directed ERD)
+- Model introspection: associations, columns, and schema file parsing
+- Self-contained single HTML file output (no external dependencies)
+- Searchable sidebar, click-to-focus, dark/light theme, keyboard shortcuts
+- Rake task (`rails_schema:generate`) and programmatic API
+- Configuration DSL: output path, title, theme, expand columns, exclude models

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

@@ -8,7 +8,7 @@
 
 **Name:** `rails-schema`
 **Module:** `Rails::Schema`
-**Version:** `0.1.0`
+**Version:** `0.1.2`
 
 Rails::Schema introspects a Rails app's models, associations, and database columns at runtime, then generates a single self-contained HTML file with an interactive, explorable entity-relationship diagram. No external server, no SaaS dependency — just one command and a browser.
 
@@ -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` |
+| **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` |
@@ -52,13 +52,23 @@ Rails::Schema.generate(output: "docs/schema.html")
 
 ```ruby
 def generate(output: nil)
-  schema_data = Extractor::SchemaFileParser.new.parse
+  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)
   generator = Renderer::HtmlGenerator.new(graph_data: graph_data)
   generator.render_to_file(output)
 end
+
+def parse_schema
+  case configuration.schema_format
+  when :ruby then Extractor::SchemaFileParser.new.parse
+  when :sql  then Extractor::StructureSqlParser.new.parse
+  when :auto
+    data = Extractor::SchemaFileParser.new.parse
+    data.empty? ? Extractor::StructureSqlParser.new.parse : data
+  end
+end
 ```
 
 ---
@@ -68,12 +78,13 @@ end
 ### 3.1 Sources of Truth
 
 1. **`db/schema.rb` parsing** — `SchemaFileParser` parses the schema file line-by-line with regex to extract table names, column definitions (name, type, nullable, default), and primary key info. This is attempted first and used as a fast, database-free source.
-2. **ActiveRecord reflection API** — `AssociationReader` uses `Model.reflect_on_all_associations` for associations (`has_many`, `belongs_to`, `has_one`, `has_and_belongs_to_many`), including `:through` and `:polymorphic`.
-3. **`Model.columns`** — `ColumnReader` falls back to `model.columns` via ActiveRecord when a table is not found in schema_data.
+2. **`db/structure.sql` parsing** — `StructureSqlParser` parses SQL `CREATE TABLE` statements for projects using `config.active_record.schema_format = :sql`. Maps SQL types to Rails-friendly types, detects `NOT NULL`, `DEFAULT` values, and primary keys. Handles schema-qualified names (`public.users`), timestamp precision (`timestamp(6)`), and both quoted and unquoted identifiers.
+3. **ActiveRecord reflection API** — `AssociationReader` uses `Model.reflect_on_all_associations` for associations (`has_many`, `belongs_to`, `has_one`, `has_and_belongs_to_many`), including `:through` and `:polymorphic`.
+4. **`Model.columns`** — `ColumnReader` falls back to `model.columns` via ActiveRecord when a table is not found in schema_data.
 
 ### 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`
@@ -83,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:
@@ -92,7 +111,19 @@ When `schema_data` is available, table existence is checked against parsed schem
 - Handles custom primary key types (`id: :uuid`, `id: :bigint`) and `id: false`
 - Skips index definitions
 
-### 3.4 Intermediate Data Format (JSON Graph)
+### 3.4 Structure SQL Parser
+
+`StructureSqlParser` provides database-free column extraction from SQL dumps:
+
+- Parses `CREATE TABLE` statements from `db/structure.sql`
+- Maps SQL types to Rails types (e.g. `character varying` → `string`, `bigint` → `bigint`, `timestamp without time zone` → `datetime`)
+- Handles schema-qualified table names (`public.users` → `users`)
+- Handles timestamp precision (`timestamp(6) without time zone`)
+- Detects primary keys from `CONSTRAINT ... PRIMARY KEY` and inline `PRIMARY KEY`
+- Extracts `NOT NULL`, `DEFAULT` values (strings, numbers, booleans)
+- Skips constraint lines (`CONSTRAINT`, `UNIQUE`, `CHECK`, `FOREIGN KEY`, etc.)
+
+### 3.5 Intermediate Data Format (JSON Graph)
 
 ```json
 {
@@ -195,6 +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, :sql, or :mongoid
 end
 ```
 
@@ -207,14 +239,20 @@ rails-schema/
 ├── lib/
 │   ├── rails/schema.rb                    # Entry point, configuration DSL, generate method
 │   └── rails/schema/
-│       ├── version.rb                     # VERSION = "0.1.0"
-│       ├── configuration.rb               # Config object (5 attributes)
+│       ├── version.rb                     # VERSION = "0.1.2"
+│       ├── configuration.rb               # Config object (6 attributes)
 │       ├── railtie.rb                     # Rails integration, rake task
 │       ├── extractor/
 │       │   ├── model_scanner.rb           # Discovers AR models
 │       │   ├── association_reader.rb      # Reads reflections
 │       │   ├── column_reader.rb           # Reads columns (schema_data or AR)
-│       │   └── schema_file_parser.rb      # Parses db/schema.rb
+│       │   ├── schema_file_parser.rb      # Parses db/schema.rb
+│       │   ├── 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
@@ -230,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
@@ -238,7 +277,13 @@ rails-schema/
 │       │   ├── model_scanner_spec.rb
 │       │   ├── column_reader_spec.rb
 │       │   ├── association_reader_spec.rb
-│       │   └── schema_file_parser_spec.rb
+│       │   ├── schema_file_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/
@@ -263,9 +308,9 @@ rails-schema/
 
 A mounted engine requires a running server. A static file can be generated in CI, committed to the repo, and opened by anyone — including non-developers looking at a data model.
 
-### Why parse schema.rb?
+### Why parse schema.rb / structure.sql?
 
-Parsing `db/schema.rb` allows column extraction without a database connection. This means the gem can work in CI environments or development setups where the database isn't running. It also avoids eager-loading the entire app just to read column metadata.
+Parsing `db/schema.rb` or `db/structure.sql` allows column extraction without a database connection. This means the gem can work in CI environments or development setups where the database isn't running. It also avoids eager-loading the entire app just to read column metadata. The `schema_format: :auto` default tries `schema.rb` first, then falls back to `structure.sql`, so the gem works out of the box regardless of which format a project uses.
 
 ### Why force-directed layout?
 
@@ -292,12 +337,12 @@ spec.add_dependency "railties", ">= 6.0"
 
 | Layer | Approach |
 |---|---|
-| Extractor | Unit tests with in-memory SQLite models (User, Post, Comment, Tag) |
+| Extractor | Unit tests with in-memory SQLite models (User, Post, Comment, Tag); rescue-path warnings tested via `output(...).to_stderr` |
 | Transformer | Pure Ruby unit tests — graph building, edge filtering |
 | Renderer | Output tests — verify HTML structure, embedded data, script injection safety |
 | Configuration | Unit tests for defaults and attribute setting |
 
-**66 tests, all passing.** Run with `bundle exec rspec`.
+**153 tests, all passing.** Run with `bundle exec rspec`.
 
 ---
 
@@ -319,4 +364,4 @@ spec.add_dependency "railties", ">= 6.0"
 
 ---
 
-*Document reflects the current implementation (v0.1.0). Future enhancements are aspirational and subject to refinement.*
+*Document reflects the current implementation (v0.1.2). Future enhancements are aspirational and subject to refinement.*

data/README.md

@@ -48,6 +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, :sql, or :mongoid
   config.exclude_models = [
     "ActiveStorage::Blob",
     "ActiveStorage::Attachment",
@@ -56,13 +57,49 @@ Rails::Schema.configure do |config|
 end
 ```
 
+| Option | Default | Description |
+|--------|---------|-------------|
+| `output_path` | `"docs/schema.html"` | Path for the generated HTML file |
+| `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`, `:sql`, or `:mongoid` (see below) |
+| `exclude_models` | `[]` | Models to hide; supports exact names and wildcard prefixes (`"ActionMailbox::*"`) |
+
+### Schema format
+
+Rails projects can use either `db/schema.rb` (Ruby DSL) or `db/structure.sql` (raw SQL dump) to represent the database schema. Set `config.active_record.schema_format = :sql` in your Rails app to use `structure.sql`.
+
+| Value | Behavior |
+|-------|----------|
+| `: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` 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 `db/schema.rb` is present (which is standard in Rails projects under version control).
+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 directly from `db/schema.rb`
+- **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/configuration.rb

@@ -3,7 +3,7 @@
 module Rails
   module Schema
     class Configuration
-      attr_accessor :output_path, :exclude_models, :title, :theme, :expand_columns
+      attr_accessor :output_path, :exclude_models, :title, :theme, :expand_columns, :schema_format
 
       def initialize
         @output_path = "docs/schema.html"
@@ -11,6 +11,7 @@ module Rails
         @title = "Database Schema"
         @theme = :auto
         @expand_columns = false
+        @schema_format = :auto
       end
     end
   end

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

@@ -26,16 +26,27 @@ module Rails
             association_type: ref.macro.to_s,
             label: ref.name.to_s,
             foreign_key: ref.foreign_key.to_s,
-            through: ref.options[:through]&.to_s,
-            polymorphic: ref.options[:as] ? true : false
+            through: through_name(ref),
+            polymorphic: polymorphic?(ref)
           }
-        rescue StandardError
+        rescue StandardError => e
+          warn "[rails-schema] Could not read association #{ref.name} on #{model.name}: #{e.class}: #{e.message}"
           nil
         end
 
+        def through_name(ref)
+          ref.options[:through]&.to_s
+        end
+
+        def polymorphic?(ref)
+          ref.options[:as] ? true : false
+        end
+
         def target_model_name(ref)
           ref.klass.name
-        rescue StandardError
+        rescue StandardError => e
+          warn "[rails-schema] Could not resolve target for #{ref.name}, " \
+               "falling back to #{ref.class_name}: #{e.class}: #{e.message}"
           ref.class_name
         end
       end

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

@@ -28,7 +28,8 @@ module Rails
               default: col.default
             }
           end
-        rescue StandardError
+        rescue StandardError => e
+          warn "[rails-schema] Could not read columns for #{model.name}: #{e.class}: #{e.message}"
           []
         end
       end

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/extractor/structure_sql_parser.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Rails
+  module Schema
+    module Extractor
+      class StructureSqlParser
+        SQL_TYPE_MAP = {
+          "character varying" => "string", "varchar" => "string",
+          "integer" => "integer", "smallint" => "integer", "serial" => "integer",
+          "bigint" => "bigint", "bigserial" => "bigint",
+          "boolean" => "boolean", "text" => "text",
+          "timestamp without time zone" => "datetime", "timestamp with time zone" => "datetime",
+          "timestamp" => "datetime",
+          "json" => "json", "jsonb" => "jsonb", "uuid" => "uuid",
+          "numeric" => "decimal", "decimal" => "decimal", "money" => "decimal",
+          "date" => "date",
+          "float" => "float", "double precision" => "float", "real" => "float",
+          "bytea" => "binary"
+        }.freeze
+
+        COMPOUND_TYPE_RE = /\A(character\s+varying|bit\s+varying|double\s+precision|
+                               timestamp(?:\(\d+\))?\s+with(?:out)?\s+time\s+zone)/ix
+        CONSTRAINT_RE = /\A(CONSTRAINT|UNIQUE|CHECK|EXCLUDE|FOREIGN\s+KEY)\b/i
+        PK_CONSTRAINT_RE = /PRIMARY\s+KEY\s*\(([^)]+)\)/i
+
+        def initialize(structure_path = nil)
+          @structure_path = structure_path
+        end
+
+        def parse
+          path = resolve_path
+          return {} unless path && File.exist?(path)
+
+          parse_content(File.read(path))
+        end
+
+        def parse_content(content)
+          tables = {}
+
+          content.scan(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([\w."]+)\s*\((.*?)\)\s*;/mi) do |table_name, body|
+            name = extract_table_name(table_name)
+            columns, pk_columns = parse_table_body(body)
+            pk_columns.each { |pk| columns.find { |c| c[:name] == pk }&.[]= :primary, true }
+            tables[name] = columns
+          end
+
+          tables
+        end
+
+        private
+
+        def resolve_path
+          return @structure_path if @structure_path
+          return ::Rails.root.join("db", "structure.sql").to_s if defined?(::Rails.root) && ::Rails.root
+
+          File.join(Dir.pwd, "db", "structure.sql")
+        end
+
+        def unquote(identifier) = identifier.delete('"')
+
+        def extract_table_name(raw)
+          unquote(raw).split(".").last
+        end
+
+        def parse_table_body(body)
+          columns = []
+          pk_columns = []
+          body.each_line do |raw|
+            line = raw.strip.chomp(",")
+            next if line.empty?
+
+            if (pk = extract_pk_constraint(line))
+              pk_columns.concat(pk)
+            elsif !line.match?(CONSTRAINT_RE) && (col = parse_column_line(line))
+              pk_columns << col[:name] if col.delete(:inline_pk)
+              columns << col
+            end
+          end
+          [columns, pk_columns]
+        end
+
+        def extract_pk_constraint(line)
+          return unless (match = line.match(PK_CONSTRAINT_RE))
+
+          match[1].split(",").map { |c| unquote(c.strip) }
+        end
+
+        def parse_column_line(line)
+          match = line.match(/\A("?\w+"?)\s+(.+)/i)
+          return nil unless match
+
+          rest = match[2]
+          type = extract_type(rest)
+          return nil unless type
+
+          build_column(unquote(match[1]), rest, type)
+        end
+
+        def build_column(col_name, rest, type)
+          {
+            name: col_name,
+            type: SQL_TYPE_MAP.fetch(type, type),
+            nullable: !rest.match?(/\bNOT\s+NULL\b/i),
+            default: extract_default(rest),
+            primary: false,
+            inline_pk: rest.match?(/\bPRIMARY\s+KEY\b/i)
+          }
+        end
+
+        def extract_type(rest)
+          if (m = rest.match(COMPOUND_TYPE_RE))
+            m[1].downcase.gsub(/\(\d+\)/, "")
+          elsif rest.match?(/\A(FOREIGN\s+KEY)\b/i)
+            nil
+          else
+            rest[/\A(\w+)/i, 1]&.downcase
+          end
+        end
+
+        def extract_default(rest)
+          case rest
+          when /\bDEFAULT\s+'([^']*)'(?:::\w+)?/i, /\bDEFAULT\s+(\d+(?:\.\d+)?)\b/i
+            Regexp.last_match(1)
+          when /\bDEFAULT\s+true\b/i then "true"
+          when /\bDEFAULT\s+false\b/i then "false"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/schema/version.rb

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

data/lib/rails/schema.rb

@@ -5,6 +5,7 @@ require_relative "schema/configuration"
 require_relative "schema/transformer/node"
 require_relative "schema/transformer/edge"
 require_relative "schema/extractor/schema_file_parser"
+require_relative "schema/extractor/structure_sql_parser"
 require_relative "schema/extractor/model_scanner"
 require_relative "schema/extractor/column_reader"
 require_relative "schema/extractor/association_reader"
@@ -29,13 +30,70 @@ module Rails
       end
 
       def generate(output: nil)
-        schema_data = Extractor::SchemaFileParser.new.parse
+        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
+
+      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
+        when :ruby
+          Extractor::SchemaFileParser.new.parse
+        when :sql
+          Extractor::StructureSqlParser.new.parse
+        when :auto
+          data = Extractor::SchemaFileParser.new.parse
+          data.empty? ? Extractor::StructureSqlParser.new.parse : data
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrei Kislichenko
@@ -45,6 +45,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - PROJECT.md
 - README.md
@@ -60,7 +62,12 @@ 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
 - lib/rails/schema/renderer/html_generator.rb
 - lib/rails/schema/transformer/edge.rb