erdb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25ee47da83fb1accfed1d03d3c4fa6b0639640961180bfe86985a9f272bac629
+  data.tar.gz: 345bc5e3caf6f76a70dbc7af2c237770c9e7938e5bd39eddfeb34d5f14cba870
+SHA512:
+  metadata.gz: 6da4c1fc2b88e3507e6e364edc27f6bb9abe7d6a3d01002224294cb2c7c302edd594cbeea0efa5d06fdb7ab7516f1c0ac0b34db9084acf488b718b26429a8970
+  data.tar.gz: 72beed6a8e53f9e1bd19360f1796980797bdfb35e5df889294602df85105cb3d5fe9773abeed0fabdcac20e69ce1f74f1709f7f3c1ff5efe5fbd6519a5c12aec

data/CHANGES.md

@@ -0,0 +1,6 @@
+### 1.0.0
+
+- Initial release
+- Added ERD generation for SQLite, PostgreSQL and MySQL
+- Use [Azimutt](https://azimutt.app) to generate the diagrams
+- Use [DBDiagram](https://dbdiagram.io) to generate the diagrams

data/README.md

@@ -0,0 +1,75 @@
+# ERDB [![Gem Version](https://badge.fury.io/rb/erdb.svg)](https://badge.fury.io/rb/erdb) [![Ruby Style Guide](https://img.shields.io/badge/code_style-rubocop-brightgreen.svg)](https://github.com/rubocop/rubocop)
+
+ERDB is a Ruby Gem for generation Entity-Relationship Diagrams (ERD).
+Currently it support `sqlite3`, `mysql2` and `postgresql` database.
+ERDB is just a wrapper to automate the process of generating ERD using -
+
+- [Azimutt(Open Source)](https://azimutt.app)
+- [DBDiagram](https://dbdiagram.io)
+
+> Currently there is no support for `one-to-one` relationship. If you want to use it you have to manually edit the generated ERD.
+
+<!-- graphviz coming soon -->
+
+## Demo
+
+![erdb](./images/erdb.gif)
+
+## Requirements
+
+- Ruby 2.7.0 or higher
+- Chrome Browser.
+
+## Installation
+
+Use the package manager [gem](https://rubygems.org/) to install ERDB.
+
+```bash
+gem install erdb
+```
+
+> Important note for Linux users: The clipboard requires the _xsel_ or the _xclip_ command-line program. On debian and ubuntu, _xsel_ can be installed with: `sudo apt-get install xsel`
+> Visit [clipboard](https://github.com/janlelis/clipboard) for more details.
+
+#### Adapters
+
+For `mysql2` and `postgresql` database, you have to install the required gem.
+I didn't include them in the gemspec because I don't want to install them if you don't need them.
+Because it depends on native extensions, you'll need a compiler and the development headers for your Ruby and database.
+
+```bash
+gem install mysql2
+gem install pg
+```
+
+## Usage
+
+After install ERDB, you can use `erdb` command to generate ER Diagram.
+
+```bash
+erdb
+```
+
+## Why I created this gem?
+
+I know there are many tools available for generating ERD,
+but I wanted to create a tool that is easy to use and can be used with any database.
+`Azimutt` also support converting schema to ERD, but it's only working well with remote databases.
+If I want to generate local database using `Azimutt`, I have to setup `Azimutt` locally that is alot of step -\_-
+
+## Roadmap
+
+- [x] Support `sqlite3`, `mysql2` and `postgresql` database.
+- [x] Generate ERD using Azimutt
+- [x] Generate ERD using DBDiagram
+- [ ] Support `MongoDB` database.
+- [ ] Generate ERD using Graphviz
+
+## Contributing
+
+Pull requests are welcome. Feel free to open an issue first to discuss what you would like to change.
+
+## License
+
+This project is licensed under [MIT](https://choosealicense.com/licenses/mit/) license.
+View [LICENSE](./LICENSE) for more details.

data/bin/erdb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/erdb"
+
+ERDB::Cli.start(ARGV)

data/lib/erdb/adapters/db.rb

@@ -0,0 +1,60 @@
+module ERDB
+  class Db
+    #
+    # @param adapter [String] The adapter to use.
+    # @param database [String] The database to connect to.
+    # @return [void]
+    #
+    def initialize(adapter, database)
+      @adapter = adapter
+      @database = database
+    end
+
+    #
+    # Connect to a database.
+    #
+    def connect
+      raise "[connect] Not implemented."
+    end
+
+    #
+    # Disconnect from a database.
+    #
+    def disconnect
+      raise "[disconnect] Not implemented."
+    end
+
+    #
+    # Convert database tables to ERD convertable Array.
+    # @return [Array] The converted hash format. see example result below.
+    #
+    # @example Example result:
+    # ```ruby
+    # [
+    #   {
+    #     name: "table_name",
+    #     is_join_table: false,
+    #     columns: [{ name: "column_name", type: "column_type" }, ...],
+    #     relations: [
+    #       {
+    #         from: {
+    #           table: "table_name",
+    #           column: "column_name"
+    #         },
+    #         to: {
+    #           table: "table_name",
+    #           column: "column_name"
+    #         }
+    #       }
+    #       ...
+    #     ]
+    #   }
+    #   ...
+    # ]
+    #  ```
+    #
+    def to_erdb
+      raise "[to_erdb] Not implemented."
+    end
+  end
+end

data/lib/erdb/adapters/nosql.rb

@@ -0,0 +1 @@
+# Planning to use this file to create a NoSQL database for the project

data/lib/erdb/adapters/sql.rb

@@ -0,0 +1,114 @@
+require "active_record"
+require_relative "db"
+
+module ERDB
+  class SQL < Db
+    #
+    # Initialize a new SQL instance.
+    #
+    def initialize(adapter, database)
+      super
+
+      @db = ActiveRecord::Base
+      @connection = nil
+    end
+
+    #
+    # Connect to a database.
+    #
+    def connect
+      puts "\n"
+      puts "Connecting to #{@adapter} database..."
+
+      case @adapter.to_sym
+      when :sqlite3
+        connect_sqlite3
+      when :postgresql, :mysql2
+        connect_with_connection_string
+      else
+        raise "Adapter not supported."
+      end
+
+      @connection = @db.connection
+    end
+
+    #
+    # Convert database tables to ERD convertable Array.
+    #
+    def to_erdb
+      puts "\nAnalyzing database..."
+      @connection.tables.map do |table|
+        columns = @connection.columns(table).map { |column| { name: column.name, type: column.type || "unknown" } }
+        relations = @connection.foreign_keys(table).map do |fk|
+          {
+            from: {
+              table: table,
+              column: fk.options[:column]
+            },
+            to: {
+              table: fk[:to_table],
+              column: fk.options[:primary_key]
+            }
+          }
+        end
+
+        hash = { name: table, columns: columns, relations: relations }
+        hash[:is_join_table] = join_table?(hash)
+        hash
+      end
+    end
+
+    #
+    # Disconnect from a database.
+    #
+    def disconnect
+      @db.remove_connection
+      @connection = nil
+    end
+
+    private
+
+    #
+    # Check current table is a join table or not.
+    #
+    # @param table [Hash] The table to check.
+    # @return [Boolean] True if the table is a join table, false otherwise.
+    #
+    def join_table?(table)
+      relations = table[:relations]
+
+      # remove data like id, created_at, updated_at
+      columns = table[:columns].map { |c| c[:name] }.reject do |column|
+        %w[id created_at updated_at].include?(column)
+      end
+
+      if relations.size == columns.size && relations.size >= 2
+        columns.include?(relations[0][:from][:column]) && columns.include?(relations[1][:from][:column])
+      else
+        false
+      end
+    end
+
+    #
+    # Connect to a SQLite3 database.
+    # @param database [String] The database to connect to.
+    # @raise [RuntimeError] If the database does not exist.
+    #
+    def connect_sqlite3
+      raise "Database does not exist." unless File.exist?(@database)
+
+      @db.establish_connection(
+        adapter: :sqlite3,
+        database: @database
+      )
+    end
+
+    #
+    # Connect to a PostgreSQL or MySQL database.
+    # @param database [String] The database to connect to.
+    #
+    def connect_with_connection_string
+      @db.establish_connection(@database)
+    end
+  end
+end

data/lib/erdb/cli.rb

@@ -0,0 +1,179 @@
+require "json"
+
+module ERDB
+  class Cli
+    class << self
+      #
+      # Start the CLI.
+      # @param [Array] args
+      # @return [void]
+      #
+      def start(_args)
+        ARGV.clear
+
+        welcome
+
+        db = select_database
+
+        erd_builder = select_diagram_builder
+
+        ERDB.show_join_table = ask_yes_no("\nDo you want to display join tables? (Y/n)", true)
+
+        db.connect
+
+        erd_builder.create(db.to_erdb)
+      rescue RuntimeError => e
+        puts "Error: #{e.message}"
+        exit 1
+      rescue Interrupt
+        puts "\n\nThank you for using ERDB!"
+        exit 0
+      end
+
+      private
+
+      #
+      # Ask user which database to use.
+      # @return [Db]
+      #
+      def select_database
+        data = {
+          sqlite3: { name: "SQLite", gem: "sqlite3" },
+          postgresql: { name: "PostgreSQL(Gem 'pg' must be installed)", gem: "pg" },
+          mysql2: { name: "MySQL(Gem 'mysql2' must be installed)", gem: "mysql2" }
+        }
+
+        puts "Select a database adapter:"
+
+        data.each_with_index do |v, i|
+          puts "#{i + 1}. #{v[1][:name]}"
+        end
+
+        response = ask_number(1, data.size)
+
+        adapter = data.keys[response.to_i - 1].to_sym
+
+        # check if the gem is installed
+        # I don't want to include the gem in the gemspec file
+        # cuz it's dependencies are too big and depend on the native library
+        # I only include sqlite3 gem cuz it's small and doesn't have any dependencies
+        gem = data[adapter][:gem]
+
+        begin
+          require gem
+        rescue LoadError
+          puts "\nError: '#{gem}' gem is not installed."
+          puts "Please install the gem '#{gem}' first."
+          puts "Run 'gem install #{gem}' to install the gem."
+          exit 1
+        end
+
+        database = if adapter == :sqlite3
+                     ask_file "\nEnter the path to the database file:"
+                   else
+                     ask "\nEnter the database connection string:"
+                   end
+
+        return SQL.new(adapter, database) if %i[sqlite3 mysql2 postgresql].include?(adapter)
+
+        raise "Invalid database adapter"
+      end
+
+      #
+      # Select a diagram builder.
+      # @return [ERDProvider]
+      #
+      def select_diagram_builder
+        data = [Azimutt, DBDiagram]
+
+        puts "\nSelect a diagram builder:"
+
+        data.each_with_index do |v, i|
+          puts "#{i + 1}. #{v.name.split('::').last}"
+        end
+
+        response = ask_number(1, data.size)
+
+        data[response.to_i - 1]
+      end
+
+      #
+      # Display welcome message.
+      #
+      def welcome
+        puts <<~WELCOME
+             .----------------.  .----------------.  .----------------.  .----------------.
+            | .--------------. || .--------------. || .--------------. || .--------------. |
+            | |  _________   | || |  _______     | || |  ________    | || |   ______     | |
+            | | |_   ___  |  | || | |_   __ \\    | || | |_   ___ `.  | || |  |_   _ \\    | |
+            | |   | |_  \\_|  | || |   | |__) |   | || |   | |   `. \\ | || |    | |_) |   | |
+            | |   |  _|  _   | || |   |  __ /    | || |   | |    | | | || |    |  __'.   | |
+            | |  _| |___/ |  | || |  _| |  \\ \\_  | || |  _| |___.' / | || |   _| |__) |  | |
+            | | |_________|  | || | |____| |___| | || | |________.'  | || |  |_______/   | |
+            | |              | || |              | || |              | || |              | |
+            | '--------------' || '--------------' || '--------------' || '--------------' |
+             '----------------'  '----------------'  '----------------'  '----------------'
+
+          ERDB is an automate tool to generate Entity-Relationship Diagrams from a database.
+          It use Azimutt and DBDiagram to generate the diagrams.
+
+        WELCOME
+      end
+
+      #
+      # Ask a question to the user.
+      # @param [String] question
+      # @return [String]
+      #
+      def ask(question = nil)
+        puts question if question
+        print "> "
+        gets.chomp
+      end
+
+      #
+      # Ask a number input to the user.
+      # @param [Integer] min
+      # @param [Integer] max
+      # @return [Integer]
+      #
+      def ask_number(min, max)
+        response = nil
+        until response.to_i.between?(min, max)
+          response = ask
+          unless response.match(/^\d+$/)
+            puts "Please enter a number"
+            response = nil
+          end
+
+          unless response.to_i.between?(min, max)
+            puts "Please enter a number between #{min} and #{max}"
+            response = nil
+          end
+        end
+        response
+      end
+
+      def ask_file(question)
+        loop do
+          file = ask question
+          return file if File.exist?(file)
+
+          puts "Invalid file path"
+        end
+      end
+
+      #
+      # Ask a yes/no question to the user.
+      # @param [String] question
+      # @param [Boolean] default
+      # @return [Boolean]
+      #
+      def ask_yes_no(question, default = true)
+        result = ask question
+
+        result.empty? ? default : result.downcase == "y"
+      end
+    end
+  end
+end

data/lib/erdb/providers/azimutt.rb

@@ -0,0 +1,134 @@
+require "clipboard"
+require "watir"
+
+module ERDB
+  class Azimutt < ERDProvider
+    class << self
+      #
+      # Create a new ER Diagram using https://azimutt.app/.
+      # @param [Hash] tables
+      #
+      def create(tables)
+        converted_data = to_aml(tables)
+
+        Utils.display_output(converted_data, "Azimutt")
+
+        start_automation(converted_data)
+      end
+
+      private
+
+      #
+      # Start the automation process to generate the ER Diagram.
+      # @param [String] data
+      # @return [void]
+      #
+      def start_automation(data)
+        browser = Watir::Browser.new(ERDB.default_browser)
+
+        browser.goto "https://azimutt.app/new"
+
+        browser.span(text: "From scratch (db design)").click
+
+        browser.button(id: "create-project-btn").click
+
+        textarea = browser.textarea(id: "source-editor")
+        textarea.click
+
+        old_clipboard = Clipboard.paste
+        Clipboard.copy(data)
+
+        # set! sometimes doesn't work cuz azimutt automatically reset incorrectly formatted data
+        # and set is also slow as hell better to use send_keys
+        # sometime naive is better than smart lol
+        #
+        # textarea.set(data)
+
+        control = Utils.is_mac? ? :command : :control
+        browser.send_keys control, "v"
+
+        Clipboard.copy(old_clipboard)
+
+        # rubocop:disable Lint/MissingCopEnableDirective
+        # rubocop:disable Layout/LineLength
+        btn = browser.button(class: "-ml-px rounded-r-md relative inline-flex items-center p-2 border border-gray-300 text-sm font-medium focus:z-10 focus:outline-none focus:ring-1 focus:ring-primary-500 focus:border-primary-500 bg-white text-gray-700 hover:bg-gray-50")
+
+        btn.click if btn.exists?
+
+        puts "Enter 'q' to exit."
+
+        loop do
+          v = gets.chomp
+          break if v == "q"
+        end
+
+        browser.close
+      end
+
+      #
+      # Convert the data to AML(Azimutt Markup Language) format.
+      #
+      # @param [Hash] tables
+      # @return [String]
+      #
+      def to_aml(tables)
+        str = ""
+        tables.each_with_index do |table, i|
+          if table[:is_join_table] && !ERDB.show_join_table?
+            str += to_many_to_many_str(table)
+            next
+          end
+
+          str += "\n\n" if i.positive?
+          str += "#{table[:name]}\n"
+          str += table[:columns].map { |c| to_column(c[:name], c[:type]) }.join("\n")
+
+          # relations
+          r = table[:relations]
+          next if r.nil? || r.empty?
+
+          r.each do |relation|
+            str += "\n"
+            f = relation[:from]
+            t = relation[:to]
+
+            str += "fk #{f[:table]}.#{f[:column]} -> #{t[:table]}.#{t[:column]}"
+          end
+        end
+        str
+      end
+
+      #
+      # Convert a column to a string.
+      # @param [String] name
+      # @param [String] type
+      #
+      def to_column(name, type)
+        "  #{name} #{type}"
+      end
+
+      #
+      # Convert a many-to-many table to a AML formatted string.
+      # @param [Hash] table
+      # @return [String]
+      #
+      def to_many_to_many_str(table)
+        str = "\n"
+        relations = Utils.to_many_to_many(table[:relations])
+
+        # Azimutt doesn't support many-to-many relations
+        # so we have to convert it to two one-to-many relations
+        # Really weird but does the job :/
+        relations.each do |relation|
+          relations.each do |other|
+            next if relation == other
+
+            str += "\nfk: #{relation} -> #{other}\n"
+          end
+        end
+
+        str
+      end
+    end
+  end
+end

data/lib/erdb/providers/dbdiagram.rb

@@ -0,0 +1,121 @@
+require "clipboard"
+require "watir"
+
+module ERDB
+  class DBDiagram < ERDProvider
+    class << self
+      #
+      # Create a new ER Diagram using https://dbdiagram.io
+      # @param [Hash] tables
+      #
+      def create(tables)
+        converted_data = to_dbdiagram_format(tables)
+
+        Utils.display_output(converted_data, "DBDiagram")
+
+        start_automation(converted_data)
+      end
+
+      private
+
+      #
+      # Start the automation process to generate the ER Diagram.
+      # @param [String] data
+      # @return [void]
+      #
+      def start_automation(data)
+        browser = Watir::Browser.new(ERDB.default_browser)
+
+        browser.goto "https://dbdiagram.io/d"
+
+        editor = browser.div(class: "view-lines monaco-mouse-cursor-text")
+        editor.click
+
+        control = Utils.is_mac? ? :command : :control
+
+        browser.send_keys control, "a"
+        browser.send_keys :delete
+
+        old_clipboard = Clipboard.paste
+        # Yep, I know this is ugly.
+        # But DBDiagram don't use input element for editor. -_-
+        Clipboard.copy(data)
+
+        browser.send_keys control, "v"
+
+        Clipboard.copy(old_clipboard)
+
+        puts "Enter 'q' to exit."
+
+        loop do
+          v = gets.chomp
+          break if v == "q"
+        end
+
+        browser.close
+      end
+
+      #
+      # Convert the data DBDiagram string format.
+      #
+      # @param [Hash] tables
+      # @return [String]
+      #
+      def to_dbdiagram_format(tables)
+        str = ""
+        tables.each_with_index do |table, i|
+          if table[:is_join_table] && !ERDB.show_join_table?
+            str += to_many_to_many_str(table)
+            next
+          end
+
+          str += "\n" if i.positive?
+          str += "Table #{table[:name]} {\n"
+          str += table[:columns].map { |c| to_column(c[:name], c[:type]) }.join("\n")
+          str += "\n}\n"
+
+          r = table[:relations]
+          next if r.nil? || r.empty?
+
+          r.each do |relation|
+            str += "\n"
+            f = relation[:from]
+            t = relation[:to]
+
+            str += "Ref: #{f[:table]}.#{f[:column]} > #{t[:table]}.#{t[:column]}"
+          end
+
+          str += "\n"
+        end
+        str
+      end
+
+      #
+      # Convert a column to a string.
+      # @param [String] name
+      # @param [String] type
+      #
+      def to_column(name, type)
+        "  #{name} #{type}"
+      end
+
+      #
+      # Convert a many-to-many table to a dbdiagram formatted string.
+      # @param [Hash] table
+      # @return [String]
+      #
+      def to_many_to_many_str(table)
+        str = ""
+        relations = Utils.to_many_to_many(table[:relations])
+
+        relations.each_with_index do |relation, i|
+          next if i.zero?
+
+          str += "\nRef: #{relations.first} <> #{relation}\n"
+        end
+
+        str
+      end
+    end
+  end
+end

data/lib/erdb/providers/erd_provider.rb

@@ -0,0 +1,11 @@
+module ERDB
+  class ERDProvider
+    #
+    # Create a new ER Diagram.
+    # @param [Hash] tables
+    #
+    def create(tables)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/erdb/utils.rb

@@ -0,0 +1,49 @@
+module ERDB
+  class Utils
+    class << self
+      #
+      # Display the ER Diagram required data.
+      # @param [String] data
+      # @param [String] provider
+      # @return [void]
+      #
+      def display_output(data, provider)
+        puts "### Copy following output to #{provider} if unexpected error happen ###"
+        puts "### Start of output ###\n\n"
+        puts data
+        puts "\n### End of output ###"
+      end
+
+      #
+      # Check if the current OS is macOS.
+      # @return [Boolean]
+      def is_mac?
+        RbConfig::CONFIG["host_os"] =~ /darwin|mac os/
+      end
+
+      #
+      # Convert the relations to ER Diagram format.
+      # @param [Array] relations
+      # @return [Array]
+      # @example
+      #   [
+      #     {
+      #       from: {
+      #         table: "users",
+      #         column: "id"
+      #       },
+      #         to: {
+      #           table: "posts",
+      #           column: "user_id"
+      #       }
+      #     }
+      #   ]
+      #   # => ["users.id", "posts.user_id"]
+      def to_many_to_many(relations)
+        relations.map do |relation|
+          "#{relation[:to][:table]}.#{relation[:to][:column]}"
+        end.uniq
+      end
+    end
+  end
+end

data/lib/erdb/version.rb

@@ -0,0 +1,3 @@
+module ERDB
+  VERSION = "1.0.0".freeze
+end

data/lib/erdb.rb

@@ -0,0 +1,38 @@
+require_relative "erdb/cli"
+require_relative "erdb/version"
+require_relative "erdb/utils"
+require_relative "erdb/providers/erd_provider"
+
+module ERDB
+  autoload :SQL, File.expand_path("erdb/adapters/sql", __dir__)
+  autoload :Azimutt, File.expand_path("erdb/providers/azimutt", __dir__)
+  autoload :DBDiagram, File.expand_path("erdb/providers/dbdiagram", __dir__)
+
+  class << self
+    attr_writer :default_timeout, :default_browser, :show_join_table
+
+    #
+    # Default wait time for wait methods.
+    # @return [Integer] Default wait time in seconds.
+    #
+    def default_timeout
+      @default_timeout ||= 30
+    end
+
+    #
+    # Default browser to use for automation.
+    # @return [Symbol]
+    #
+    def default_browser
+      @default_browser ||= :chrome
+    end
+
+    #
+    # Show join table in the diagram.
+    # @return [Boolean]
+    #
+    def show_join_table?
+      @show_join_table.nil? ? true : @show_join_table
+    end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: erdb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Wai Yan Phyo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: clipboard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: watir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+description: ERDB is a Ruby Gem for generation Entity-Relationship Diagrams (ERD).
+email: oyhpnayiaw@gmail.com
+executables:
+- erdb
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGES.md
+- README.md
+- bin/erdb
+- lib/erdb.rb
+- lib/erdb/adapters/db.rb
+- lib/erdb/adapters/nosql.rb
+- lib/erdb/adapters/sql.rb
+- lib/erdb/cli.rb
+- lib/erdb/providers/azimutt.rb
+- lib/erdb/providers/dbdiagram.rb
+- lib/erdb/providers/erd_provider.rb
+- lib/erdb/utils.rb
+- lib/erdb/version.rb
+homepage: https://github.com/oyhpnayiaw/erdb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/oyhpnayiaw/erdb
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: ERDB is a Ruby Gem for generation Entity-Relationship Diagrams (ERD).
+test_files: []