erbee 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4058446709d36b729b7771aa2d261686e19586816fcac65c6de80d649c3df87f
-  data.tar.gz: ba2528945f35dbb48d73ff594aea3d77f9f94d04cd55b85d738d66bbf789ea4e
+  metadata.gz: 30b52ebea6705191f221bc4b963b8c8d8a21220edd585baacb302f1d00065bee
+  data.tar.gz: 3311df2ced5a719ba38127c2db7f260048b495d7fda5ba406b7f7c07571f329c
 SHA512:
-  metadata.gz: 79d37934763e32e268afb17ae0469238e968b50bd9616521d64929e3c3813de7abdcc113e338be108c6ba3794b1ee7e244013510ff5d10e9d733a8aa129f7cd9
-  data.tar.gz: 18191084b2c14e416e5eeccb37b3880ec6699fe6dfa62d9736d4eb763bcc8cb3541b606c3a687a7fd4505dba55282cdc4c3f2b971b8bdddacbb3799c9dd2707c
+  metadata.gz: 68e064938a7724aa8010f2f9a12e77b7a90f655465e3ef8b396c083710f94ac8320a4a385ea8cad4a574ee2034e5fb6a1b748ddb6c2a0fd0dad0e77a2f657597
+  data.tar.gz: ed469134ce42651a711e995a6c54982d84b5d8eda44c3ae82c3a1cb0116639c258db0e902b98d1636a91e3af6f1fc43074b02975fc04a2183b834f174151677c

data/README.md

@@ -1,471 +1,52 @@
 # Erbee
 
-Erbee is a Ruby gem designed to automatically generate Entity-Relationship (ER) diagrams for your Rails applications. Leveraging the power of [Mermaid](https://mermaid-js.github.io/) for visualization, Erbee provides an easy and flexible way to visualize your database schema and model associations directly from your Rails models.
+**Erbee** is a simple gem that generates Mermaid-based ER diagrams for your existing Rails or ActiveRecord projects.  
+You run a single command, get a `.md` file (in Mermaid format), then convert it to `.svg` via Docker if you wish.
 
-## Table of Contents
+---
 
-- [Features](#features)
-- [Installation](#installation)
-- [Configuration](#configuration)
-- [Usage](#usage)
-    - [Generating ER Diagrams](#generating-er-diagrams)
-    - [Output Options](#output-options)
-- [Testing](#testing)
-    - [Local File Output Test](#local-file-output-test)
-    - [Tempfile Output Test](#tempfile-output-test)
-- [Examples](#examples)
-    - [Sample ER Diagram](#sample-er-diagram)
+## 1. Quick Installation & Setup
 
-## Features
+1. **Add Erbee to your Gemfile** (in your existing project):
+  ```ruby
+  # Gemfile
+  gem 'erbee'
+  ```
+2. **Install the gem**:
+  ```bash
+  bundle install
+  ```
+3. **Run the CLI (inside your project directory)**:
+  ```bash
+  bundle exec erbee User --depth=1
+  ```
+  - This outputs a Mermaid .md file (e.g. er_diagram.md) with your database entities and associations.
 
-- **Automatic ER Diagram Generation**: Generate ER diagrams based on your Rails models and their associations.
-- **Mermaid Integration**: Utilize Mermaid's `erDiagram` syntax for clear and interactive diagrams.
-- **Flexible Output Options**: Output diagrams to local Markdown files or temporary files for testing purposes.
-- **Customizable Configuration**: Easily configure output paths and generation settings.
-- **Comprehensive Testing**: Includes tests for generating large ER diagrams with up to 50 tables and random relationships.
+## 2. Converting Mermaid .md to .svg
 
-## Installation
-
-Add Erbee to your application's Gemfile:
-
-```ruby
-gem 'erbee'
-```
-
-And then execute:
+To view the diagram as an SVG, you can use Docker and the mermaid-cli container:
 
 ```bash
-bundle install
-```
-Or install it yourself as:
-
-```ruby
-gem install erbee
-```
-
-## Configuration
-Erbee can be configured to specify output paths and other settings. You can configure Erbee in an initializer or directly within your Ruby scripts.
-
-### Example Configuration
-
-```ruby
-Erbee.configure do |config|
-  config.output_path = "path/to/your/erdiagram.md" # Specify your desired output path
-  config.depth = 2 # Specify the depth for association exploration (optional)
-end
-```
-
-## Usage
-Erbee provides a straightforward interface to generate ER diagrams from your Rails models.
-
-### Generating ER Diagrams
-You can generate an ER diagram by invoking the `DiagramRenderer` with your model information.
-
-#### Example:
-```ruby
-# lib/erbee/diagram_renderer.rb
-require 'erbee/model_info'
-require 'ostruct'
-
-module Erbee
-  class DiagramRenderer
-    def initialize(model_infos)
-      @model_infos = model_infos
-      @output_path = Erbee.configuration.output_path
-    end
-
-    def render
-      mermaid_code = build_mermaid_er
-      File.write(@output_path, mermaid_code)
-      puts "Generated ER diagram (Mermaid erDiagram) at: #{@output_path}"
-    end
-
-    private
-
-    # Generates Mermaid erDiagram syntax
-    def build_mermaid_er
-      lines = []
-      lines << "```mermaid"
-      lines << "erDiagram"
-
-      # Table Definitions
-      @model_infos.each do |model_info|
-        lines << build_table_definition(model_info)
-      end
-
-      # Relationships
-      visited_edges = {}
-      @model_infos.each do |model_info|
-        model_info.associations.each do |assoc|
-          src_table = model_info.model_class.table_name
-          dst_info = @model_infos.find { |mi| mi.model_class.name == assoc[:class_name] }
-          next unless dst_info
-
-          dst_table = dst_info.model_class.table_name
-
-          edge_key = [src_table, dst_table].sort.join("-")
-          next if visited_edges[edge_key]
-
-          visited_edges[edge_key] = true
-
-          relation_str = mermaid_relation(assoc[:type], src_table, dst_table)
-          lines << "    #{relation_str}"
-        end
-      end
-
-      lines << "```"
-      lines.join("\n")
-    end
-
-    # Builds table definition in Mermaid syntax
-    def build_table_definition(model_info)
-      table_name = model_info.model_class.table_name
-      columns_def = model_info.columns.map do |col|
-        "#{mermaid_type(col[:type])} #{col[:name]}"
-      end
-
-      definition_lines = []
-      definition_lines << "    #{table_name} {"
-      columns_def.each do |c|
-        definition_lines << "        #{c}"
-      end
-      definition_lines << "    }"
-      definition_lines.join("\n")
-    end
-
-    # Defines relationships based on association type
-    def mermaid_relation(assoc_type, src_table, dst_table)
-      case assoc_type
-      when :belongs_to
-        "#{src_table} |{--|| #{dst_table} : \"N:1\""
-      when :has_many
-        "#{src_table} ||--|{ #{dst_table} : \"1:N\""
-      when :has_one
-        "#{src_table} ||--|| #{dst_table} : \"1:1\""
-      when :has_and_belongs_to_many
-        "#{src_table} }|--|{ #{dst_table} : \"N:N\""
-      else
-        "#{src_table} ||--|| #{dst_table} : \"1:1\""
-      end
-    end
-
-    # Converts Rails column types to Mermaid types
-    def mermaid_type(col_type)
-      case col_type
-      when :integer
-        "int"
-      when :float, :decimal
-        "float"
-      when :datetime, :date, :time, :timestamp
-        "datetime"
-      when :boolean
-        "boolean"
-      else
-        "string"
-      end
-    end
-  end
-end
-```
-
-### Output Options
-Erbee allows you to output the generated ER diagram to either a local Markdown file or a temporary file for testing.
-
-####  Local File Output
-Configure Erbee to output to a specific file path:
-
-```ruby
-Erbee.configure do |config|
-  config.output_path = "spec/output/erdiagram.md"
-end
-
-model_infos = Erbee::AssociationExplorer.new("User", depth: 2).explore
-renderer = Erbee::DiagramRenderer.new(model_infos)
-renderer.render
-```
-
-#### Temporary File Output (For Testing)
-For testing purposes, you can use Ruby's Tempfile to generate a temporary file that gets deleted after use.
-
-```ruby
-require "tempfile"
-
-tmpfile = Tempfile.new(["erdiagram", ".md"])
-Erbee.configure do |config|
-  config.output_path = tmpfile.path
-end
-
-model_infos = Erbee::AssociationExplorer.new("User", depth: 2).explore
-renderer = Erbee::DiagramRenderer.new(model_infos)
-renderer.render
-
-# After testing
-tmpfile.close
-tmpfile.unlink
-```
-
-### Testing
-Erbee includes comprehensive tests to ensure the reliability of ER diagram generation, even with large and complex schemas.
-
-#### Setting Up Tests
-Ensure that you have RSpec installed and properly configured in your project. Erbee's tests include helpers for generating random model data.
-
-##### Random Model Info Helper
-Create a helper to generate random model information for testing.
-
-```ruby
-# spec/support/random_model_info_helper.rb
-require 'ostruct'
-
-module RandomModelInfoHelper
-  # Generates an array of random ModelInfo objects with consistent associations
-  def create_random_model_infos(table_count = 50, seed = 12345)
-    # Fix the random seed for reproducibility
-    srand seed
-
-    # Generate table names: table01, table02, ..., table50
-    table_names = (1..table_count).map { |i| "table%02d" % i }
-
-    # Initialize ModelInfo objects with random columns
-    model_infos = table_names.map do |tname|
-      # Randomly assign 2 to 5 columns
-      col_count = rand(2..5)
-      columns = col_count.times.map do |i|
-        {
-          name: "col#{('A'.ord + i).chr}",  # colA, colB, etc.
-          type: random_type,                # :integer, :string, etc.
-          null: [true, false].sample
-        }
-      end
-
-      # Initialize associations empty, to be filled later
-      associations = []
-
-      # Create a fake model_class object with name and table_name
-      fake_class = OpenStruct.new(
-        name: tname.capitalize,  # e.g., "Table01"
-        table_name: tname        # e.g., "table01"
-      )
-
-      Erbee::ModelInfo.new(
-        model_class:  fake_class,
-        associations: associations,
-        columns:      columns
-      )
-    end
-
-    # Assign consistent associations
-    model_infos.each do |mi|
-      rand(0..3).times do
-        assoc_type = random_assoc_type
-        target = (model_infos - [mi]).sample
-        next if target.nil?
-
-        # Avoid duplicate associations
-        existing_assoc = mi.associations.find { |a| a[:class_name] == target.model_class.name }
-        next if existing_assoc
-
-        case assoc_type
-        when :belongs_to
-          # Current model belongs_to target
-          mi.associations << {
-            name:       "#{target.model_class.table_name}_ref".to_sym,
-            type:       :belongs_to,
-            class_name: target.model_class.name
-          }
-
-          # Ensure target has has_many for current model
-          target.associations << {
-            name:       "#{mi.model_class.table_name}_collection".to_sym,
-            type:       :has_many,
-            class_name: mi.model_class.name
-          }
-        when :has_one
-          # Current model has_one target
-          mi.associations << {
-            name:       "#{target.model_class.table_name}_ref".to_sym,
-            type:       :has_one,
-            class_name: target.model_class.name
-          }
-
-          # Ensure target has belongs_to for current model
-          target.associations << {
-            name:       "#{mi.model_class.table_name}_ref".to_sym,
-            type:       :belongs_to,
-            class_name: mi.model_class.name
-          }
-        when :has_many, :has_and_belongs_to_many
-          # Current model has_many or has_and_belongs_to_many target
-          mi.associations << {
-            name:       "#{target.model_class.table_name}_collection".to_sym,
-            type:       assoc_type,
-            class_name: target.model_class.name
-          }
-
-          # Ensure target has belongs_to or has_and_belongs_to_many for current model
-          inverse_type = assoc_type == :has_many ? :belongs_to : :has_and_belongs_to_many
-          target.associations << {
-            name:       "#{mi.model_class.table_name}_ref".to_sym,
-            type:       inverse_type,
-            class_name: mi.model_class.name
-          }
-        end
-      end
-    end
-
-    model_infos
-  end
-
-  private
-
-  # Returns a random column type
-  def random_type
-    [:integer, :string, :datetime, :boolean].sample
-  end
-
-  # Returns a random association type
-  def random_assoc_type
-    [:belongs_to, :has_many, :has_one, :has_and_belongs_to_many].sample
-  end
-end
-```
-
-#### RSpec Configuration
-Ensure that the spec/support directory is loaded by RSpec by adding the following to your spec/spec_helper.rb or spec/rails_helper.rb:
-
-```ruby
-# spec/spec_helper.rb or spec/rails_helper.rb
-
-RSpec.configure do |config|
-  # Load support files
-  Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require f }
-
-  # Other configurations...
-end
+# Example: Using the minlag/mermaid-cli Docker image
+# - Mount the current directory so Mermaid can read/write files
+docker run -it --rm \
+-v "$PWD":/data \
+minlag/mermaid-cli \
+-i er_diagram.md -o er_diagram.svg
 ```
 
-### Local File Output Test
-This test generates a Mermaid erDiagram with 50 random tables and relationships, saving the output to a local file for manual inspection.
-
-```ruby
-# spec/erbee/diagram_renderer_large_spec.rb
-require "spec_helper"
-require "fileutils"
-
-RSpec.describe Erbee::DiagramRenderer do
-  include RandomModelInfoHelper
-
-  it "generates a Mermaid erDiagram for 50 random tables, saved locally" do
-    # 1. Generate random ModelInfo array with fixed seed
-    model_infos = create_random_model_infos(50, seed = 12345)
-
-    # 2. Define output path (e.g., spec/output/random_erdiagram.md)
-    output_dir = "spec/output"
-    FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
-    local_md_path = File.join(output_dir, "random_erdiagram.md")
-
-    # 3. Configure Erbee to output to the local file
-    Erbee.configure do |config|
-      config.output_path = local_md_path
-    end
+Now you have er_diagram.svg in your project folder—open it in any browser or image viewer.
 
-    # 4. Render the diagram
-    renderer = Erbee::DiagramRenderer.new(model_infos)
-    renderer.render
+## 3. View the SVG in Your Browser
 
-    # 5. Assertions
-    expect(File).to exist(local_md_path)
-    content = File.read(local_md_path)
-
-    # Check that the content includes the Mermaid code block and 'erDiagram'
-    expect(content).to include("```mermaid")
-    expect(content).to include("erDiagram")
-
-    # Check that some table definitions are present
-    expect(content).to include("table01 {")
-    expect(content).to include("table50 {")
-
-    # Check that relationships are defined
-    # Example: "table01 ||--|{ table02 : "1:N""
-    expect(content).to match(/table\d{2}\s+\|\|--\|\{\s+table\d{2}/)
-
-    # Output the path for manual inspection
-    puts "Generated ER diagram saved at: #{local_md_path}"
-
-    # Do not delete the file for manual inspection
-  end
-end
-```
-
-### Tempfile Output Test
-This test generates a Mermaid erDiagram with 50 random tables and relationships, saving the output to a temporary file that gets deleted after the test.
-
-```ruby
-# spec/erbee/diagram_renderer_tempfile_spec.rb
-require "spec_helper"
-require "tempfile"
-
-RSpec.describe Erbee::DiagramRenderer do
-  include RandomModelInfoHelper
-
-  it "generates a Mermaid erDiagram for 50 random tables using Tempfile and deletes it after" do
-    # 1. Generate random ModelInfo array with fixed seed
-    model_infos = create_random_model_infos(50, seed = 12345)
-
-    # 2. Create a Tempfile for output
-    tmpfile = Tempfile.new(["random_erdiagram", ".md"])
-
-    # 3. Configure Erbee to output to the Tempfile
-    Erbee.configure do |config|
-      config.output_path = tmpfile.path
-    end
-
-    # 4. Render the diagram
-    renderer = Erbee::DiagramRenderer.new(model_infos)
-    renderer.render
-
-    # 5. Assertions
-    expect(File).to exist(tmpfile.path)
-    content = File.read(tmpfile.path)
-
-    # Check that the content includes the Mermaid code block and 'erDiagram'
-    expect(content).to include("```mermaid")
-    expect(content).to include("erDiagram")
-
-    # Check that some table definitions are present
-    expect(content).to include("table01 {")
-    expect(content).to include("table50 {")
-
-    # Check that relationships are defined
-    # Example: "table01 ||--|{ table02 : "1:N""
-    expect(content).to match(/table\d{2}\s+\|\|--\|\{\s+table\d{2}/)
-
-    # Output the path for debugging (file will be deleted)
-    puts "Generated ER diagram saved at: #{tmpfile.path}"
-
-    # 6. Cleanup: close and delete the Tempfile
-    tmpfile.close
-    tmpfile.unlink  # This deletes the file
-  end
-end
+Depending on your OS, run one of these commands:
+- **macOS**:
+```bash
+open er_diagram.svg
 ```
-
-## Examples
-### Sample ER Diagram
-Here's an example of how a generated ER diagram might look in Markdown using Mermaid's erDiagram syntax:
-
-```merkdown
-erDiagram
-    users {
-        int id
-        string name
-    }
-    posts {
-        int id
-        string title
-        int user_id
-    }
-    users ||--|{ posts : "1:N"
+- **Linux**:
+```bash
+xdg-open er_diagram.svg
 ```
 
-When rendered with a Mermaid-compatible viewer, this will display an ER diagram showing a one-to-many relationship between `users` and `posts`.
+After that, your browser (or default viewer) should display the diagram.

data/lib/erbee/association_explorer.rb

@@ -1,12 +1,15 @@
-require 'active_record'
+require "active_record"
+require_relative "polymorphic_collector"
 
 module Erbee
   class AssociationExplorer
     def initialize(model_name, depth: Erbee.configuration.depth)
       @model_name = model_name
       @depth = depth
-      @visited = {}  # { model_class => current_depth }
-      @results = []  # Array of ModelInfo
+      @visited = {}
+      @results = []
+      # We use an existing PolymorphicCollector to gather reverse-polymorphic associations.
+      @polymorphic_registry = PolymorphicCollector.collect!
     end
 
     def explore
@@ -19,16 +22,29 @@ module Erbee
 
     def traverse(model_class, current_depth)
       return if current_depth > @depth
+      # If we've already visited this model at an equal or lower depth, skip.
       return if @visited.key?(model_class) && @visited[model_class] <= current_depth
 
       @visited[model_class] = current_depth
 
       model_info = build_model_info(model_class)
-      @results << model_info unless @results.any? { |m| m.model_class == model_class }
+      unless @results.any? { |m| m.model_class == model_class }
+        @results << model_info
+      end
+
+      # Use the associations from model_info to recurse further
+      model_info.associations.each do |assoc|
+        next_class_names = assoc[:class_name].is_a?(Array) ? assoc[:class_name] : [assoc[:class_name]]
+        next_class_names.each do |cn|
+          next if cn == "POLYMORPHIC"
 
-      model_class.reflect_on_all_associations.each do |assoc|
-        next_model_class = assoc.klass
-        traverse(next_model_class, current_depth + 1)
+          begin
+            next_model = cn.constantize
+            traverse(next_model, current_depth + 1)
+          rescue NameError
+            # Skip if the class doesn't exist
+          end
+        end
       end
     end
 
@@ -37,24 +53,64 @@ module Erbee
     end
 
     def build_model_info(model_class)
-      associations = model_class.reflect_on_all_associations.map do |assoc|
-        {
-          name: assoc.name,
-          type: assoc.macro,       # :belongs_to, :has_many, :has_one, etc.
-          class_name: assoc.klass.name
-        }
+      associations = model_class.reflect_on_all_associations.flat_map do |assoc|
+        # 1) belongs_to with polymorphic: true
+        if assoc.macro == :belongs_to && assoc.polymorphic?
+          # Example: belongs_to :customer, polymorphic: true
+          poly_name = assoc.name.to_s
+          # The collector may return multiple owner classes if they all have has_many ... as: poly_name
+          possible_owners = @polymorphic_registry.possible_owners(poly_name)
+          if possible_owners.empty?
+            # Fallback if no owners are found
+            [{
+               name: assoc.name,
+               type: assoc.macro,            # e.g., :belongs_to
+               polymorphic: true,
+               class_name: "POLYMORPHIC"
+             }]
+          else
+            possible_owners.map do |owner_class_name|
+              {
+                name: assoc.name,
+                type: assoc.macro,
+                polymorphic: true,
+                class_name: owner_class_name
+              }
+            end
+          end
+
+          # 2) has_many (or has_one) with as: :xxx => reverse polymorphic
+        elsif %i[has_many has_one].include?(assoc.macro) && assoc.options[:as].present?
+          # Example: has_many :images, as: :imageable
+          # Rails reflection returns assoc.polymorphic? == false, but we manually set polymorphic: true here
+          [{
+             name: assoc.name,
+             type: assoc.macro,   # e.g., :has_many
+             polymorphic: true,   # Reverse polymorphic side
+             class_name: assoc.klass.name
+           }]
+
+        else
+          # 3) Normal association
+          [{
+             name: assoc.name,
+             type: assoc.macro,   # :belongs_to, :has_many, ...
+             polymorphic: false,
+             class_name: assoc.klass.name
+           }]
+        end
       end
 
       columns = model_class.columns.map do |col|
         { name: col.name, type: col.type, null: col.null }
       end
 
+      # ModelInfo is initialized with keyword arguments
       ModelInfo.new(
-        model_class: model_class,
+        model_class:  model_class,
         associations: associations,
-        columns: columns
+        columns:      columns
       )
     end
   end
 end
-

data/lib/erbee/diagram_renderer.rb

@@ -27,25 +27,42 @@ module Erbee
         lines << build_table_definition(model_info)
       end
 
-      # Relationships (TABLE1 ||--|{ TABLE2 : "1:N" )
+      # Relationships
       visited_edges = {}
       @model_infos.each do |model_info|
         model_info.associations.each do |assoc|
-          # Source and Destination table names
-          src_table = model_info.model_class.table_name
-          dst_info = @model_infos.find { |mi| mi.model_class.name == assoc[:class_name] }
-          next unless dst_info
+          # Some associations may have an array of class_name if polymorphic => multiple owners
+          class_names = assoc[:class_name].is_a?(Array) ? assoc[:class_name] : [assoc[:class_name]]
 
-          dst_table = dst_info.model_class.table_name
+          class_names.each do |dst_class_name|
+            if dst_class_name == "POLYMORPHIC"
+              # We can either skip or draw a dummy node. Example: skip or draw a placeholder
+              # Here we demonstrate a dummy edge:
+              lines << "    #{draw_poly_dummy_edge(model_info, assoc)}"
+              next
+            end
 
-          # Do not write duplicate edges that have been used once
-          edge_key = [src_table, dst_table].sort.join("-")
-          next if visited_edges[edge_key]
-          visited_edges[edge_key] = true
+            # Find the corresponding model info for dst_class_name
+            dst_info = @model_infos.find { |mi| mi.model_class.name == dst_class_name }
+            next unless dst_info
 
-          # Get relation symbol
-          relation_str = mermaid_relation(assoc[:type], src_table, dst_table)
-          lines << "    #{relation_str}"
+            src_table = model_info.model_class.table_name
+            dst_table = dst_info.model_class.table_name
+
+            # Avoid duplicates
+            edge_key = [src_table, dst_table].sort.join("-")
+            next if visited_edges[edge_key]
+            visited_edges[edge_key] = true
+
+            # Render the relationship
+            relation_str = mermaid_relation(
+              assoc[:type],             # e.g. :has_many or :belongs_to
+              src_table,
+              dst_table,
+              assoc[:polymorphic]       # e.g. true or false
+            )
+            lines << "    #{relation_str}"
+          end
         end
       end
 
@@ -53,17 +70,11 @@ module Erbee
       lines.join("\n")
     end
 
-    # Table definition section
-    # Example:
-    # TableName {
-    #    int id
-    #    string name
-    # }
+    # Build the table definition in Mermaid syntax
     def build_table_definition(model_info)
       table_name = model_info.model_class.table_name
       columns_def = model_info.columns.map do |col|
-        # e.g. "int id", "string name"
-        # Example of slightly converting the type to resemble Mermaid:
+        # Convert col[:type] to Mermaid-like type
         "#{mermaid_type(col[:type])} #{col[:name]}"
       end
 
@@ -76,44 +87,6 @@ module Erbee
       definition_lines.join("\n")
     end
 
-    # Outputs symbols like 1:1 / 1:N / N:N based on the type of relationship
-    # In Mermaid's erDiagram, you can use symbols like ||--|| for 1:1, ||--|{ for 1:N, }|--|{ for N:N, etc.
-    # Example: "TABLE1 ||--|{ TABLE2 : "1:N""
-    def mermaid_relation(assoc_type, src_table, dst_table)
-      # Example of provisional mapping:
-      # belongs_to → 1:1 (??) or "N:1", actual determination is a bit more complex
-      # has_many → 1:N
-      # has_one → 1:1
-      # (many-to-many → has_and_belongs_to_many → N:N)
-      # Here, simply:
-      # belongs_to: src is N, dst is 1
-      # has_many:   src is 1, dst is N
-      # has_one:    src is 1, dst is 1
-      # has_and_belongs_to_many: N:N
-      # If unknown, treat as 1:1
-      case assoc_type
-      when :belongs_to
-        # If "Post" belongs_to "User", then Post:User = N:1
-        # => Post |{--|| User
-        # (In Mermaid's erDiagram, "TABLE1 |{--|| TABLE2" means TABLE1:N, TABLE2:1)
-        "#{src_table} |{--|| #{dst_table} : \"N:1\""
-      when :has_many
-        # "User" has_many "Posts" => User:Posts = 1:N
-        # => User ||--|{ Post
-        "#{src_table} ||--|{ #{dst_table} : \"1:N\""
-      when :has_one
-        # => 1:1
-        "#{src_table} ||--|| #{dst_table} : \"1:1\""
-      when :has_and_belongs_to_many
-        # => N:N
-        "#{src_table} }|--|{ #{dst_table} : \"N:N\""
-      else
-        # fallback -> 1:1
-        "#{src_table} ||--|| #{dst_table} : \"1:1\""
-      end
-    end
-
-    # Simple conversion of column types
     # If you have types like integer/string/datetime in SQLite, you can align with Mermaid's notation
     def mermaid_type(col_type)
       case col_type
@@ -129,5 +102,37 @@ module Erbee
         "string"
       end
     end
+
+    # Provide relationship symbols in Mermaid's erDiagram
+    # e.g. belongs_to -> N:1, has_many -> 1:N
+    # If is_poly is true, we can optionally alter the notation
+    def mermaid_relation(assoc_type, src_table, dst_table, is_poly)
+      # assoc_type = :belongs_to / :has_many, is_poly = true/false
+      case assoc_type
+      when :belongs_to
+        if is_poly
+          "#{src_table} |{--|| #{dst_table} : \"N:1 (poly)\""
+        else
+          "#{src_table} |{--|| #{dst_table} : \"N:1\""
+        end
+      when :has_many
+        if is_poly
+          "#{src_table} ||--|{ #{dst_table} : \"1:N (poly)\""
+        else
+          "#{src_table} ||--|{ #{dst_table} : \"1:N\""
+        end
+      else
+        # fallback -> 1:1
+        "#{src_table} ||--|| #{dst_table} : \"1:1\""
+      end
+    end
+
+    # Draw a dummy edge if class_name is "POLYMORPHIC"
+    def draw_poly_dummy_edge(model_info, assoc)
+      src_table = model_info.model_class.table_name
+      # e.g. just show it as a special node
+      # "image" -- "(poly: imageable)"
+      %Q(#{src_table} -- "(poly:#{assoc[:name]})")
+    end
   end
 end

data/lib/erbee/polymorphic_collector.rb

@@ -0,0 +1,25 @@
+require_relative "polymorphic_registry"
+
+module Erbee
+  class PolymorphicCollector
+    def self.collect!
+      # After eager_load! is called, we retrieve all models from ActiveRecord::Base.descendants.
+      # Then we collect reverse-polymorphic associations (e.g., has_many :images, as: :imageable).
+      registry = PolymorphicRegistry.new
+
+      ActiveRecord::Base.descendants.each do |model|
+        model.reflect_on_all_associations.each do |assoc|
+          # Check if the macro is :has_many or :has_one and the :as option is present.
+          # Example: has_many :images, as: :imageable
+          next unless %i[has_many has_one].include?(assoc.macro) && assoc.options[:as].present?
+
+          polymorphic_name = assoc.options[:as].to_s
+          association_name = assoc.name.to_s  # e.g., "images"
+          registry.add(polymorphic_name, association_name, model.name)
+        end
+      end
+
+      registry
+    end
+  end
+end

data/lib/erbee/polymorphic_registry.rb

@@ -0,0 +1,31 @@
+module Erbee
+  class PolymorphicRegistry
+    # The data structure is: { polymorphic_name => { association_name => [Array of owner class names] } }
+    # For example: { "imageable" => { "images" => ["User", "Article"] } }
+    # This holds the models that declare something like 'has_many :images, as: :imageable'.
+
+    attr_reader :map
+
+    def initialize
+      # Initialize @map so that each key references a nested hash
+      @map = Hash.new { |h, k| h[k] = {} }
+    end
+
+    # Register a has_many ... as: :polymorphic_name
+    # For example, add("imageable", "images", "User") means:
+    #  "User" has 'has_many :images, as: :imageable'
+    def add(polymorphic_name, association_name, owner_class)
+      @map[polymorphic_name][association_name] ||= []
+      @map[polymorphic_name][association_name] << owner_class
+    end
+
+    # For example, if polymorphic_name = "imageable",
+    # possible_owners("imageable") might return ["User", "Article", ...]
+    # because each one has 'has_many :images, as: :imageable'.
+    def possible_owners(polymorphic_name)
+      # We gather all associated class arrays across the nested hash and flatten them:
+      #   @map["imageable"].values.flatten.uniq
+      @map[polymorphic_name].values.flatten.uniq
+    end
+  end
+end

data/lib/erbee/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Erbee
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erbee
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - allister0098
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-19 00:00:00.000000000 Z
+date: 2025-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -56,7 +56,7 @@ description: Erbee is a Ruby gem designed to automatically generate Entity-Relat
   (ER) diagrams for your Rails applications. Leveraging the power of Mermaid for visualization,
   Erbee provides an easy and flexible way to visualize your database schema and model
   associations directly from your Rails models.
-email:
+email: taro0098egg@gmail.com
 executables:
 - erbee
 extensions: []
@@ -73,6 +73,8 @@ files:
 - lib/erbee/configuration.rb
 - lib/erbee/diagram_renderer.rb
 - lib/erbee/model_info.rb
+- lib/erbee/polymorphic_collector.rb
+- lib/erbee/polymorphic_registry.rb
 - lib/erbee/version.rb
 - sig/erbee.rbs
 homepage: https://github.com/allister0098/erbee