rails-schema 0.1.2 → 0.1.4

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; }
@@ -356,19 +375,35 @@ body {
 
 #detail-content {
   padding: 16px;
+  padding-top: calc(var(--toolbar-height) + 16px);
   width: var(--detail-width);
 }
 
+.detail-header {
+  display: flex;
+  align-items: center;
+  position: relative;
+  padding-right: 28px;
+}
+
 #detail-content h2 {
+  flex: 1;
+  min-width: 0;
   font-size: 18px;
   font-weight: 700;
   margin-bottom: 4px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
 #detail-content .detail-table {
   font-size: 12px;
   color: var(--text-secondary);
   margin-bottom: 16px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
 #detail-content h3 {
@@ -437,15 +472,16 @@ body {
 }
 
 #detail-close {
-  position: absolute;
-  top: 12px;
-  right: 12px;
   background: none;
   border: none;
   color: var(--text-secondary);
   cursor: pointer;
   font-size: 18px;
   padding: 4px;
+  flex-shrink: 0;
+  position: absolute;
+  top: -8px;
+  right: 0;
 }
 
 /* Legend */
@@ -473,6 +509,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/model_scanner.rb

@@ -6,7 +6,7 @@ module Rails
       class ModelScanner
         def initialize(configuration: ::Rails::Schema.configuration, schema_data: nil)
           @configuration = configuration
-          @schema_data = schema_data
+          @schema_data = schema_data.nil? || schema_data.empty? ? nil : schema_data
         end
 
         def scan
@@ -43,7 +43,7 @@ module Rails
           else
             loader.eager_load
           end
-        rescue StandardError => e
+        rescue StandardError, LoadError => e
           warn "[rails-schema] Zeitwerk eager_load failed (#{e.class}: #{e.message}), " \
                "trying Rails.application.eager_load!"
           eager_load_via_application!
@@ -51,7 +51,7 @@ module Rails
 
         def eager_load_via_application!
           ::Rails.application.eager_load!
-        rescue StandardError => e
+        rescue StandardError, LoadError => e
           warn "[rails-schema] eager_load! failed (#{e.class}: #{e.message}), " \
                "falling back to per-file model loading"
           eager_load_model_files!
@@ -63,9 +63,9 @@ module Rails
           models_path = ::Rails.root.join("app", "models")
           return unless models_path.exist?
 
-          Dir.glob(models_path.join("**/*.rb")).each do |file|
+          Dir.glob(models_path.join("**/*.rb")).sort.each do |file|
             require file
-          rescue StandardError => e
+          rescue StandardError, LoadError => e
             warn "[rails-schema] Could not load #{file}: #{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, *args, **kwargs, &block)
+            if model.respond_to?(method)
+              model.send(method, *args, **kwargs, &block)
+            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")).sort.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")).sort.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

@@ -19,9 +19,9 @@ module Rails
         }.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
+                               timestamp(?:\(\d+\))?\s+with(?:out)?\s+time\s+zone)/ix.freeze
+        CONSTRAINT_RE = /\A(CONSTRAINT|UNIQUE|CHECK|EXCLUDE|FOREIGN\s+KEY)\b/i.freeze
+        PK_CONSTRAINT_RE = /PRIMARY\s+KEY\s*\(([^)]+)\)/i.freeze
 
         def initialize(structure_path = nil)
           @structure_path = structure_path
@@ -56,7 +56,9 @@ module Rails
           File.join(Dir.pwd, "db", "structure.sql")
         end
 
-        def unquote(identifier) = identifier.delete('"')
+        def unquote(identifier)
+          identifier.delete('"')
+        end
 
         def extract_table_name(raw)
           unquote(raw).split(".").last

data/lib/rails/schema/transformer/graph_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Rails
   module Schema
     module Transformer
@@ -10,9 +12,12 @@ module Rails
         end
 
         def build(models)
-          node_names = models.to_set(&:name)
-          nodes = models.map { |m| build_node(m) }
-          edges = models.flat_map { |m| build_edges(m, node_names) }
+          model_ids = assign_unique_ids(models)
+          name_to_id = {}
+          model_ids.each { |m, uid| name_to_id[m.name] ||= uid }
+
+          nodes = model_ids.map { |m, uid| build_node(m, uid) }
+          edges = model_ids.flat_map { |m, uid| build_edges(m, uid, name_to_id) }
 
           {
             nodes: nodes.map(&:to_h),
@@ -23,21 +28,29 @@ module Rails
 
         private
 
-        def build_node(model)
+        def assign_unique_ids(models)
+          counts = models.group_by(&:name).transform_values(&:size)
+          models.map do |m|
+            uid = counts[m.name] > 1 ? "#{m.name} (#{m.table_name})" : m.name
+            [m, uid]
+          end
+        end
+
+        def build_node(model, unique_id)
           Node.new(
-            id: model.name,
+            id: unique_id,
             table_name: model.table_name,
             columns: @column_reader.read(model)
           )
         end
 
-        def build_edges(model, node_names)
+        def build_edges(model, unique_id, name_to_id)
           @association_reader.read(model).filter_map do |assoc|
-            next unless node_names.include?(assoc[:to])
+            next unless name_to_id.key?(assoc[:to])
 
             Edge.new(
-              from: assoc[:from],
-              to: assoc[:to],
+              from: unique_id,
+              to: name_to_id[assoc[:to]],
               association_type: assoc[:association_type],
               label: assoc[:label],
               foreign_key: assoc[:foreign_key],

data/lib/rails/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Rails
   module Schema
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   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