erbee 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4058446709d36b729b7771aa2d261686e19586816fcac65c6de80d649c3df87f
+  data.tar.gz: ba2528945f35dbb48d73ff594aea3d77f9f94d04cd55b85d738d66bbf789ea4e
+SHA512:
+  metadata.gz: 79d37934763e32e268afb17ae0469238e968b50bd9616521d64929e3c3813de7abdcc113e338be108c6ba3794b1ee7e244013510ff5d10e9d733a8aa129f7cd9
+  data.tar.gz: 18191084b2c14e416e5eeccb37b3880ec6699fe6dfa62d9736d4eb763bcc8cb3541b606c3a687a7fd4505dba55282cdc4c3f2b971b8bdddacbb3799c9dd2707c

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/README.md

@@ -0,0 +1,471 @@
+# 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.
+
+## 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)
+
+## Features
+
+- **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.
+
+## Installation
+
+Add Erbee to your application's Gemfile:
+
+```ruby
+gem 'erbee'
+```
+
+And then execute:
+
+```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
+```
+
+### 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
+
+    # 4. Render the diagram
+    renderer = Erbee::DiagramRenderer.new(model_infos)
+    renderer.render
+
+    # 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
+```
+
+## 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"
+```
+
+When rendered with a Mermaid-compatible viewer, this will display an ER diagram showing a one-to-many relationship between `users` and `posts`.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/erbee

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "erbee"
+
+module Erbee
+  class CLI
+    def self.start(argv)
+      self.load_rails_application
+
+      puts "Loading Rails application succeeded!"
+
+      options = {
+        depth: 2,
+        output_path: "er_diagram.md"
+      }
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: erbee MODEL [options]"
+
+        opts.on("--depth=DEPTH", Integer, "Association exploration depth (default: 2)") do |d|
+          options[:depth] = d
+        end
+
+        opts.on("--output=PATH", "Output file path (default: er_diagram.md)") do |o|
+          options[:output_path] = o
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          puts opts
+          exit
+        end
+      end
+
+      parser.parse!(argv)
+
+      # The first argument is expected to be the model name
+      model_name = argv[0]
+      if model_name.nil?
+        puts parser
+        exit 1
+      end
+
+      # Configure Erbee using the parsed options
+      Erbee.configure do |config|
+        config.depth = options[:depth]
+        config.output_path = options[:output_path]
+      end
+
+      explorer = Erbee::AssociationExplorer.new(model_name, depth: Erbee.configuration.depth)
+      model_infos = explorer.explore
+
+      renderer = Erbee::DiagramRenderer.new(model_infos)
+      renderer.render
+
+      puts "ER diagram generated at #{Erbee.configuration.output_path}"
+    end
+
+    def self.load_rails_application
+      if File.exist?("config/environment.rb")
+        begin
+          require File.expand_path("config/environment.rb", Dir.pwd)
+
+          if defined?(Rails)
+            Rails.application.eager_load!
+            Rails.application.config.eager_load_namespaces.each(&:eager_load!) if Rails.application.config.respond_to?(:eager_load_namespaces)
+          end
+
+        rescue LoadError
+          puts <<~MSG
+            Could not load config/environment.rb. Some models may not be loaded,
+            resulting in an incomplete diagram. If you're using ActiveRecord without Rails,
+            ensure your models are manually required before running this command.
+          MSG
+          exit 1
+
+        rescue TypeError
+          puts <<~MSG
+            Failed to eager load models. Some classes may remain unloaded,
+            leading to an incomplete diagram. Please check your environment setup.
+          MSG
+          exit 1
+        end
+      else
+        puts "No Rails application found in the current directory."
+        exit 1
+      end
+    end
+  end
+end
+
+# Call the CLI entry point with the arguments provided by the user
+Erbee::CLI.start(ARGV)

data/lib/erbee/association_explorer.rb

@@ -0,0 +1,60 @@
+require 'active_record'
+
+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
+    end
+
+    def explore
+      start_model = model_class_for(@model_name)
+      traverse(start_model, 0)
+      @results
+    end
+
+    private
+
+    def traverse(model_class, current_depth)
+      return if current_depth > @depth
+      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 }
+
+      model_class.reflect_on_all_associations.each do |assoc|
+        next_model_class = assoc.klass
+        traverse(next_model_class, current_depth + 1)
+      end
+    end
+
+    def model_class_for(name)
+      name.constantize
+    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
+        }
+      end
+
+      columns = model_class.columns.map do |col|
+        { name: col.name, type: col.type, null: col.null }
+      end
+
+      ModelInfo.new(
+        model_class: model_class,
+        associations: associations,
+        columns: columns
+      )
+    end
+  end
+end
+

data/lib/erbee/cli.rb

@@ -0,0 +1,13 @@
+module Erbee
+  class CLI
+    def self.start(args)
+      model_name = args[0] || raise("Please specify a model name")
+      explorer = AssociationExplorer.new(model_name)
+      model_infos = explorer.explore
+
+      renderer = DiagramRenderer.new(model_infos)
+      renderer.render
+    end
+  end
+end
+

data/lib/erbee/configuration.rb

@@ -0,0 +1,11 @@
+module Erbee
+  class Configuration
+    attr_accessor :depth, :output_path
+
+    def initialize
+      @depth = 2
+      @output_path = "er_diagram.md"
+    end
+  end
+end
+

data/lib/erbee/diagram_renderer.rb

@@ -0,0 +1,133 @@
+require 'securerandom'
+
+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 syntax for ER Diagram
+    def build_mermaid_er
+      lines = []
+      # Start of code block
+      lines << "```mermaid"
+      lines << "erDiagram"
+
+      # Table definition section (TABLE { ... } )
+      @model_infos.each do |model_info|
+        lines << build_table_definition(model_info)
+      end
+
+      # Relationships (TABLE1 ||--|{ TABLE2 : "1:N" )
+      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
+
+          dst_table = dst_info.model_class.table_name
+
+          # 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
+
+          # Get relation symbol
+          relation_str = mermaid_relation(assoc[:type], src_table, dst_table)
+          lines << "    #{relation_str}"
+        end
+      end
+
+      lines << "```"
+      lines.join("\n")
+    end
+
+    # Table definition section
+    # Example:
+    # TableName {
+    #    int id
+    #    string name
+    # }
+    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:
+        "#{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
+
+    # 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
+      when :integer
+        "int"
+      when :float, :decimal
+        "float"
+      when :datetime, :date, :time, :timestamp
+        "datetime"
+      when :boolean
+        "boolean"
+      else
+        "string"
+      end
+    end
+  end
+end

data/lib/erbee/model_info.rb

@@ -0,0 +1,9 @@
+module Erbee
+  ModelInfo = Struct.new(
+    :model_class,
+    :associations,
+    :columns,
+    keyword_init: true
+  )
+end
+

data/lib/erbee/version.rb

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

data/lib/erbee.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "erbee/version"
+require "erbee/configuration"
+require "erbee/association_explorer"
+require "erbee/model_info"
+require "erbee/diagram_renderer"
+require "erbee/cli"
+
+module Erbee
+  class Error < StandardError; end
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/sig/erbee.rbs

@@ -0,0 +1,4 @@
+module Erbee
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: erbee
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- allister0098
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Erbee is a Ruby gem designed to automatically generate Entity-Relationship
+  (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:
+executables:
+- erbee
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- exe/erbee
+- lib/erbee.rb
+- lib/erbee/association_explorer.rb
+- lib/erbee/cli.rb
+- lib/erbee/configuration.rb
+- lib/erbee/diagram_renderer.rb
+- lib/erbee/model_info.rb
+- lib/erbee/version.rb
+- sig/erbee.rbs
+homepage: https://github.com/allister0098/erbee
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Automatically generate ER diagrams for Rails applications using Mermaid.
+test_files: []