rails-erd 2.0.2 → 2.2.0

data/lib/rails_erd/domain.rb

@@ -128,6 +128,7 @@ module RailsERD
                     .reject { |model| tableless_rails_models.include?(model) }
                     .select { |model| check_model_validity(model) }
                     .reject { |model| check_habtm_model(model) }
+                    .sort_by { |model| model.name.to_s }
     end
 
     # Returns Rails model classes defined in the app
@@ -187,7 +188,39 @@ module RailsERD
     def excluded_model?(model)
       return false unless options.exclude.present?
 
-      [options.exclude].flatten.map(&:to_sym).include?(model.name.to_sym)
+      patterns = [options.exclude].flatten
+      patterns.any? { |pattern| matches_pattern?(pattern, model.name) }
+    end
+
+    # Matches a name against a pattern. Supports three pattern types:
+    #
+    # - Exact match: "Foo" matches only "Foo"
+    # - Glob pattern: "SolidQueue::*" matches "SolidQueue::Job", etc.
+    # - Regex pattern: "/^Active/" matches "ActiveRecord", "ActiveStorage::Blob"
+    #
+    def matches_pattern?(pattern, name)
+      pattern_str = pattern.to_s
+
+      # Regex pattern: /pattern/ or /pattern/flags
+      #
+      if pattern_str.start_with?("/") && pattern_str =~ %r{\A/(.+)/([imx]*)\z}
+        regex_body = Regexp.last_match(1)
+        flags_str = Regexp.last_match(2)
+        flags = 0
+        flags |= Regexp::IGNORECASE if flags_str.include?("i")
+        flags |= Regexp::MULTILINE if flags_str.include?("m")
+        flags |= Regexp::EXTENDED if flags_str.include?("x")
+        return Regexp.new(regex_body, flags).match?(name.to_s)
+      end
+
+      # Glob pattern: contains *, ?, or [
+      #
+      if pattern_str.include?("*") || pattern_str.include?("?") || pattern_str.include?("[")
+        return File.fnmatch?(pattern_str, name.to_s)
+      end
+
+      # Exact match (backward compatible)
+      pattern_str == name.to_s
     end
 
     def check_association_validity(association)
@@ -207,13 +240,14 @@ module RailsERD
     def excluded_association?(association)
       return false unless options.exclude.present?
 
-      excluded_names = [options.exclude].flatten.map(&:to_sym)
+      patterns = [options.exclude].flatten
 
       # Suppress warning if either the source model or target model is excluded
-      return true if excluded_names.include?(association.active_record.name.to_sym)
+      source_name = association.active_record.name
+      return true if patterns.any? { |pattern| matches_pattern?(pattern, source_name) }
 
       target_name = association.options[:polymorphic] ? association.class_name : association.klass.name
-      target_name && excluded_names.include?(target_name.to_sym)
+      target_name && patterns.any? { |pattern| matches_pattern?(pattern, target_name) }
     rescue NameError
       # If we can't determine the target class, the source model was already checked above
       false

data/lib/rails_erd/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module RailsERD
-  VERSION = "2.0.2"
+  VERSION = "2.2.0"
   BANNER  = "RailsERD #{VERSION}"
 end

data/lib/rails_erd.rb

@@ -51,12 +51,14 @@ module RailsERD
         :notation, :simple,
         :orientation, :horizontal,
         :polymorphism, false,
+        :recursive, true,
         :sort, true,
         :warn, true,
         :title, true,
         :exclude, nil,
         :exclude_attributes, nil,
         :only, nil,
+        :only_attributes, nil,
         :only_recursion_depth, nil,
         :prepend_primary, false,
         :cluster, false,

data/test/test_helper.rb

@@ -1,7 +1,7 @@
 require "rubygems"
 require "bundler/setup"
 require 'pry'
-require 'pry-nav'
+require 'pry-byebug'
 require 'tmpdir'
 
 require "active_record"

data/test/unit/config_test.rb

@@ -133,6 +133,17 @@ class ConfigTest < ActiveSupport::TestCase
     assert_equal expected, normalize_value(:exclude_attributes, "BigTable,User.password_digest")
   end
 
+  test "normalize_value should canonicalize a hash when key is :only_attributes." do
+    value = { "Book" => ["title", "isbn"] }
+    expected = { "Book" => ["title", "isbn"] }
+    assert_equal expected, normalize_value(:only_attributes, value)
+  end
+
+  test "normalize_value should parse a string when key is :only_attributes." do
+    expected = { "Book" => ["title", "isbn"] }
+    assert_equal expected, normalize_value(:only_attributes, "Book.title,Book.isbn")
+  end
+
   test "normalize_value should return hash with symbol keys when key is :fonts and value is a hash." do
     fonts_value = { "normal" => "Arial", "bold" => "Arial Bold", "italic" => "Arial Italic" }
     expected = {:normal => "Arial", :bold => "Arial Bold", :italic => "Arial Italic"}

data/test/unit/diagram_test.rb

@@ -165,6 +165,76 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal [Author, Editor], retrieve_entities(:only => ['Author', 'Editor']).map(&:model)
   end
 
+  test "generate should exclude relationships whose endpoints were removed by :only" do
+    create_model "Author"
+    create_model "Book", :author => :references do
+      belongs_to :author
+      has_many :reviews
+    end
+    create_model "Review", :book => :references do
+      belongs_to :book
+    end
+    relationships = retrieve_relationships(:only => [:Author, :Book])
+    assert_equal [Set[Author, Book]], relationships.map { |r| Set[r.source.model, r.destination.model] }
+  end
+
+  test "generate should exclude relationships to an excluded entity" do
+    create_model "Author"
+    create_model "Book", :author => :references do
+      belongs_to :author
+      has_many :reviews
+    end
+    create_model "Review", :book => :references do
+      belongs_to :book
+    end
+    relationships = retrieve_relationships(:exclude => [:Review])
+    assert_equal [Set[Author, Book]], relationships.map { |r| Set[r.source.model, r.destination.model] }
+  end
+
+  # Pattern matching for exclude/only ==========================================
+  test "generate should filter entities matching glob pattern in exclude" do
+    create_module_model "SolidQueue::Job"
+    create_module_model "SolidQueue::Process"
+    create_model "User"
+    assert_equal [User], retrieve_entities(:exclude => ["SolidQueue::*"]).map(&:model)
+  end
+
+  test "generate should filter entities matching regex pattern in exclude" do
+    create_module_model "SolidQueue::Job"
+    create_model "User"
+    assert_equal [User], retrieve_entities(:exclude => ["/^Solid/"]).map(&:model)
+  end
+
+  test "generate should include only entities matching glob pattern in only" do
+    create_module_model "MyApp::User"
+    create_module_model "MyApp::Post"
+    create_model "SomeOther"
+    entities = retrieve_entities(:only => ["MyApp::*"]).map(&:model)
+    assert_includes entities, MyApp::User
+    assert_includes entities, MyApp::Post
+    refute_includes entities, SomeOther
+  end
+
+  test "generate should include only entities matching regex pattern in only" do
+    create_model "AdminUser"
+    create_model "AdminPost"
+    create_model "GuestUser"
+    entities = retrieve_entities(:only => ["/^Admin/"]).map(&:model)
+    assert_includes entities, AdminUser
+    assert_includes entities, AdminPost
+    refute_includes entities, GuestUser
+  end
+
+  test "generate should exclude relationships when endpoint matches glob pattern" do
+    create_module_model "SolidQueue::Job"
+    create_model "Task", :solid_queue_job => :references do
+      belongs_to :solid_queue_job, :class_name => "SolidQueue::Job"
+    end
+    create_model "User"
+    relationships = retrieve_relationships(:exclude => ["SolidQueue::*"])
+    assert_equal [], relationships
+  end
+
   test "generate should filter disconnected entities if disconnected is false" do
     create_model "Book", :author => :references do
       belongs_to :author
@@ -235,7 +305,7 @@ class DiagramTest < ActiveSupport::TestCase
     create_model "Baz", :foo => :references do
       belongs_to :foo
     end
-    assert_equal [false, false, true], retrieve_relationships(:indirect => true).map(&:indirect?)
+    assert_equal({ false => 2, true => 1 }, retrieve_relationships(:indirect => true).map(&:indirect?).tally)
   end
 
   test "generate should filter indirect relationships if indirect is false" do
@@ -253,6 +323,20 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal [false, false], retrieve_relationships(:indirect => false).map(&:indirect?)
   end
 
+  test "generate should yield self referential relationships if recursive is true" do
+    create_model "Node", :parent => :references do
+      belongs_to :parent, :class_name => "Node"
+    end
+    assert_equal [true], retrieve_relationships(:recursive => true).map(&:recursive?)
+  end
+
+  test "generate should filter self referential relationships if recursive is false" do
+    create_model "Node", :parent => :references do
+      belongs_to :parent, :class_name => "Node"
+    end
+    assert_equal [], retrieve_relationships(:recursive => false)
+  end
+
   test "generate should yield relationships from specialized entities" do
     create_model "Foo", :bar => :references
     create_model "Bar", :type => :string
@@ -302,6 +386,21 @@ class DiagramTest < ActiveSupport::TestCase
       :polymorphism => true).map { |s| s.specialized.name }
   end
 
+  test "generate should not yield specializations whose entity is not part of the domain" do
+    # An abstract parent whose child model has no table (e.g. ActionMailbox::Record
+    # with a tableless ActionMailbox::InboundEmail): the child is excluded from the
+    # domain, so the specialization resolves to a nameless Null entity. It must not
+    # be yielded, otherwise generators emit an edge to a nameless entity (which is
+    # invalid Mermaid output).
+    Object.const_set "GhostRecord", Class.new(ActiveRecord::Base) { self.abstract_class = true }
+    Object.const_set "GhostThing", Class.new(GhostRecord)
+
+    specializations = retrieve_specializations(:inheritance => true, :polymorphism => true)
+    assert_equal [], specializations.select { |s|
+      s.generalized.name.to_s.empty? || s.specialized.name.to_s.empty?
+    }
+  end
+
   # Attribute filtering ======================================================
   test "generate should yield content attributes by default" do
     create_model "Book", :title => :string, :created_at => :datetime, :author => :references do
@@ -388,4 +487,95 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal %w{title}, attribute_lists[Book].map(&:name)
     assert_equal [], attribute_lists[Author].map(&:name)
   end
+
+  test "generate should show only the listed attributes for a model" do
+    create_model "Book", :title => :string, :subtitle => :string, :pages => :integer
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title", "pages"] })
+    assert_equal %w{pages title}, attribute_lists[Book].map(&:name).sort
+  end
+
+  test "generate should restrict attributes for the listed model only" do
+    create_model "Book", :title => :string, :subtitle => :string
+    create_model "Author", :name => :string, :born_on => :date
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title"] })
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+    assert_equal %w{born_on name}, attribute_lists[Author].map(&:name).sort
+  end
+
+  test "generate should accept only_attributes as a string" do
+    create_model "Book", :title => :string, :subtitle => :string
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:only_attributes => "Book.title")
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+    assert_equal %w{name}, attribute_lists[Author].map(&:name)
+  end
+
+  test "generate should keep all attributes for a model listed in only_attributes without any attribute" do
+    create_model "Book", :title => :string, :subtitle => :string
+    attribute_lists = retrieve_attribute_lists(:only_attributes => "Book")
+    assert_equal %w{subtitle title}, attribute_lists[Book].map(&:name).sort
+  end
+
+  test "generate should not show attributes selected by only_attributes but rejected by attributes" do
+    create_model "Book", :title => :string, :created_at => :datetime
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title", "created_at"] },
+      :attributes => [:content])
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+  end
+
+  test "generate should apply only_attributes before exclude_attributes" do
+    create_model "Book", :title => :string, :subtitle => :string, :pages => :integer
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title", "subtitle"] },
+      :exclude_attributes => { "Book" => ["subtitle"] })
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+  end
+
+  test "generate should hide all attributes when a model is in both only_attributes and fully excluded" do
+    create_model "Book", :title => :string, :subtitle => :string
+    attribute_lists = retrieve_attribute_lists(:only_attributes => { "Book" => ["title"] },
+      :exclude_attributes => { "Book" => true })
+    assert_equal [], attribute_lists[Book].map(&:name)
+  end
+
+  test "normalize_only_attributes should split namespaced models on the first dot only" do
+    assert_equal({ "Admin::User" => ["email"] },
+      Diagram.normalize_only_attributes("Admin::User.email"))
+  end
+
+  test "normalize_only_attributes should return an empty hash for nil" do
+    assert_equal({}, Diagram.normalize_only_attributes(nil))
+  end
+
+  test "normalize_only_attributes should return an empty hash for false" do
+    assert_equal({}, Diagram.normalize_only_attributes(false))
+  end
+
+  test "normalize_only_attributes should raise for true" do
+    assert_raises ArgumentError do
+      Diagram.normalize_only_attributes(true)
+    end
+  end
+
+  test "normalize_exclude_attributes should split namespaced models on the first dot only" do
+    assert_equal({ "Admin::User" => ["password_digest"] },
+      Diagram.normalize_exclude_attributes("Admin::User.password_digest"))
+  end
+
+  test "normalize_exclude_attributes should treat a bare namespaced model as hide all" do
+    assert_equal({ "Admin::User" => true },
+      Diagram.normalize_exclude_attributes("Admin::User"))
+  end
+
+  test "normalize_exclude_attributes should return an empty hash for nil" do
+    assert_equal({}, Diagram.normalize_exclude_attributes(nil))
+  end
+
+  test "normalize_exclude_attributes should return an empty hash for false" do
+    assert_equal({}, Diagram.normalize_exclude_attributes(false))
+  end
+
+  test "normalize_exclude_attributes should ignore blank entries in a string" do
+    assert_equal({ "Book" => true },
+      Diagram.normalize_exclude_attributes("Book, ,"))
+  end
 end

data/test/unit/domain_test.rb

@@ -151,6 +151,23 @@ class DomainTest < ActiveSupport::TestCase
     assert_equal ["Many", "More"], [relationship.source.name, relationship.destination.name]
   end
 
+  test "relationships should be deterministic regardless of model order" do
+    create_model "Author"
+    create_model "Book", :author => :references do
+      belongs_to :author
+      has_many :reviews
+    end
+    create_model "Review", :book => :references do
+      belongs_to :book
+    end
+    pairs = lambda do |models|
+      Domain.new(models).relationships.collect { |r| [r.source.name, r.destination.name] }
+    end
+    models = [Author, Book, Review]
+    # Order and source/destination direction must not depend on the input model order.
+    assert_equal pairs.call(models), pairs.call(models.reverse)
+  end
+
   # Specialization processing ================================================
   test "specializations should return empty array for empty domain" do
     assert_equal [], Domain.generate.specializations
@@ -301,4 +318,91 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal "", output
   end
+
+  # Pattern matching for exclude/only ==========================================
+  test "matches_pattern? should match exact string" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "Foo", "Foo")
+    refute domain.send(:matches_pattern?, "Foo", "Bar")
+  end
+
+  test "matches_pattern? should match glob pattern with asterisk" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "SolidQueue::*", "SolidQueue::Job")
+    assert domain.send(:matches_pattern?, "SolidQueue::*", "SolidQueue::Process")
+    refute domain.send(:matches_pattern?, "SolidQueue::*", "SolidCache::Entry")
+  end
+
+  test "matches_pattern? should match glob pattern without namespace separator" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "ActiveStorage*", "ActiveStorageBlob")
+    assert domain.send(:matches_pattern?, "ActiveStorage*", "ActiveStorage::Blob")
+    refute domain.send(:matches_pattern?, "ActiveStorage*", "ActionMailbox::InboundEmail")
+  end
+
+  test "matches_pattern? should match regex pattern" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "/^Active/", "ActiveRecord")
+    assert domain.send(:matches_pattern?, "/^Active/", "ActiveStorage::Blob")
+    refute domain.send(:matches_pattern?, "/^Active/", "SolidQueue::Job")
+  end
+
+  test "matches_pattern? should match regex pattern with flags" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "/queue/i", "SolidQueue::Job")
+    refute domain.send(:matches_pattern?, "/queue/", "SolidQueue::Job")
+  end
+
+  test "excluded_model? should match glob patterns" do
+    create_module_model "SolidQueue::Job"
+    create_module_model "SolidQueue::Process"
+    create_model "User"
+
+    domain = Domain.generate(:exclude => ["SolidQueue::*"])
+
+    # excluded_model? returns true for matching patterns
+    assert domain.send(:excluded_model?, SolidQueue::Job)
+    assert domain.send(:excluded_model?, SolidQueue::Process)
+    refute domain.send(:excluded_model?, User)
+  end
+
+  test "excluded_model? should match regex patterns" do
+    create_module_model "SolidQueue::Job"
+    create_model "User"
+
+    domain = Domain.generate(:exclude => ["/^Solid/"])
+    assert domain.send(:excluded_model?, SolidQueue::Job)
+    refute domain.send(:excluded_model?, User)
+  end
+
+  test "excluded_model? should still match exact names for backward compatibility" do
+    create_model "Foo"
+    create_model "Bar"
+
+    domain = Domain.generate(:exclude => ["Foo"])
+    assert domain.send(:excluded_model?, Foo)
+    refute domain.send(:excluded_model?, Bar)
+  end
+
+  test "excluded_association? should match glob patterns for source model" do
+    create_module_model "SolidQueue::Job" do
+      has_many :executions
+    end
+    create_model "User"
+
+    domain = Domain.generate(:exclude => ["SolidQueue::*"], :warn => false)
+    association = SolidQueue::Job.reflect_on_association(:executions)
+    assert domain.send(:excluded_association?, association)
+  end
+
+  test "excluded_association? should match glob patterns for target model" do
+    create_module_model "SolidQueue::Execution"
+    create_model "Task" do
+      has_many :executions, :class_name => "SolidQueue::Execution"
+    end
+
+    domain = Domain.generate(:exclude => ["SolidQueue::*"], :warn => false)
+    association = Task.reflect_on_association(:executions)
+    assert domain.send(:excluded_association?, association)
+  end
 end

data/test/unit/mermaid_test.rb

@@ -188,13 +188,30 @@ class MermaidTest < ActiveSupport::TestCase
       "\tclass `Cannon`",
       "\tclass `Galleon`",
       "\tclass `Stronghold`",
-      "\t`Defensible` --> `Cannon`",
       "\t`Galleon` --> `Cannon`",
       "\t`Stronghold` --> `Cannon`"
     ]
     assert_equal expected, diagram.graph.uniq
   end
 
+  test "generate should not draw polymorphic entity that is omitted by only" do
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+    end
+
+    expected = [
+      "classDiagram",
+      "\tdirection TB",
+      "\tclass `Cannon`",
+      "\tclass `Galleon`",
+      "\t`Galleon` --> `Cannon`"
+    ]
+    assert_equal expected, diagram(:only => %w{Cannon Galleon}).graph.uniq
+  end
+
   test "generate should support one to many relationships" do
     create_one_to_many_assoc_domain
 
@@ -230,9 +247,9 @@ class MermaidTest < ActiveSupport::TestCase
       "\tclass `Bar`",
       "\tclass `Baz`",
       "\tclass `Foo`",
-      "\t`Foo` --> `Baz`",
       "\t`Foo` --> `Bar`",
-      "\t`Bar` ..> `Baz`"
+      "\t`Bar` ..> `Baz`",
+      "\t`Foo` --> `Baz`"
     ]
 
     assert_equal expected, diagram.graph.uniq
@@ -437,4 +454,126 @@ class MermaidTest < ActiveSupport::TestCase
     # Verify the specialization relationship line also quotes it
     assert result.match?(/Vehicle.*--.*"Transport::Car"/), "Specialization relationship should quote namespaced entity"
   end
+
+  # Namespace clustering tests (Issue #479) =====================================
+
+  test "classDiagram with cluster should group entities by namespace" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+    create_module_model "Admin::Role"
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    assert result.include?("classDiagram")
+    # Should have namespace block for Admin
+    assert result.include?("namespace Admin {"), "Should have namespace block for Admin"
+    # Author and Role should be inside the Admin namespace
+    assert result.match?(/namespace Admin \{[^}]*class `Author`/m), "Author should be inside Admin namespace"
+    assert result.match?(/namespace Admin \{[^}]*class `Role`/m), "Role should be inside Admin namespace"
+  end
+
+  test "classDiagram with cluster should place entities without namespace outside blocks" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    # Post should appear before any namespace block
+    post_index = result.index("class `Post`")
+    namespace_index = result.index("namespace Admin {")
+    assert post_index < namespace_index, "Entities without namespace should appear before namespace blocks"
+  end
+
+  test "classDiagram with cluster should handle nested namespaces" do
+    create_model "Post"
+    create_module_model "Admin::Users::Role", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    # Nested namespace should use dot notation (Admin.Users)
+    assert result.include?("namespace Admin.Users {"), "Should convert :: to . in namespace names"
+    assert result.match?(/namespace Admin\.Users \{[^}]*class `Role`/m), "Role should be inside Admin.Users namespace"
+  end
+
+  test "classDiagram with cluster should render relationships outside namespace blocks" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    # Relationship should appear after the namespace block closes
+    namespace_close_index = result.index("}")
+    relationship_index = result.index("`Post` --> `Admin::Author`")
+    assert relationship_index > namespace_close_index, "Relationships should appear after namespace blocks"
+  end
+
+  test "erDiagram with cluster should emit warning and render flat" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    test_diagram = nil
+
+    warning_output = collect_stdout do
+      domain = Domain.generate
+      test_diagram = Diagram::Mermaid.new(domain, :cluster => true, :mermaid_style => :erdiagram, :warn => true)
+      test_diagram.generate
+    end
+
+    result = test_diagram.graph.join("\n")
+
+    # Should emit warning about clustering not supported
+    assert warning_output.include?("Clustering is not supported"), "Should warn about clustering not supported in erDiagram"
+    # Should still render the diagram (flat, no namespace blocks)
+    assert result.include?("erDiagram")
+    refute result.include?("namespace"), "erDiagram should not have namespace blocks"
+  end
+
+  test "classDiagram with cluster false should not group entities" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => false).graph.join("\n")
+
+    assert result.include?("classDiagram")
+    # Should NOT have namespace blocks
+    refute result.include?("namespace"), "cluster: false should not create namespace blocks"
+    # Should use full entity names
+    assert result.include?("class `Admin::Author`"), "Should use full entity name without clustering"
+  end
+
+  test "classDiagram with cluster and inheritance should emit entities before specializations" do
+    create_model "Vehicle", :type => :string
+    create_module_model "Transport::Car", Vehicle
+
+    result = diagram(:cluster => true, :inheritance => true).graph.join("\n")
+
+    # Entity class definitions should appear BEFORE specialization lines
+    vehicle_class_index = result.index("class `Vehicle`")
+    polymorphic_index = result.index("<<polymorphic>>")
+    inheritance_index = result.index("<|--")
+
+    assert vehicle_class_index, "Should have Vehicle class definition.\nGot:\n#{result}"
+    assert polymorphic_index, "Should have polymorphic marker.\nGot:\n#{result}"
+    assert inheritance_index, "Should have inheritance relationship.\nGot:\n#{result}"
+
+    # The key assertion: class definitions must come BEFORE specializations
+    assert vehicle_class_index < polymorphic_index,
+      "Class definitions should appear before polymorphic markers.\n" \
+      "Got:\n#{result}"
+    assert vehicle_class_index < inheritance_index,
+      "Class definitions should appear before inheritance relationships.\n" \
+      "Got:\n#{result}"
+  end
 end