dbml2mmd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 261de0186edf17eb6c43954acedcfb0757cd20eedd3e4071614b8f02338ea2f0
+  data.tar.gz: 23f8cb563d34fc9b5a585da92809015207a56bfe08726fab98769764a2143894
+SHA512:
+  metadata.gz: c587842ee993f2a9ccb2b71c246ebb53620beef4406d2b1d832becdc40864099b06d4fe1f8a2fc5af285ecdc8fe6544415c9b4ba033b41b1f1b08c3b6ef8942d
+  data.tar.gz: '09ed6b16f069788d6381991256e85dedc543b8a3f69d5446240faad92d805dc60b0543bb158c4832e378e01add97402599d013c803ed92135d1c32a0b2df0a4c'

data/LICENSE

@@ -0,0 +1,32 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.

data/README.md

@@ -0,0 +1,102 @@
+# dbml2mmd
+
+A command-line tool to convert DBML (Database Markup Language) files to Mermaid Markdown format for database diagram visualization.
+
+## Overview
+
+dbml2mmd transforms your DBML schema definitions into Mermaid Markdown diagrams, making it easy to include your database schema diagrams in documentation, GitHub READMEs, or any platform that supports Mermaid.
+
+## Installation
+
+## Usage
+
+### Basic Usage
+
+Convert a single DBML file to Mermaid Markdown:
+
+```bash
+dbml2mmd input.dbml
+```
+
+This will create `input.mmd` in the same directory.
+
+### Specify Output File
+
+```bash
+dbml2mmd input.dbml -o output.mmd
+```
+
+### Process Multiple Files
+
+```bash
+dbml2mmd *.dbml
+```
+
+### Watch for Changes
+
+```bash
+dbml2mmd input.dbml --watch
+```
+
+### Help
+
+```bash
+dbml2mmd --help
+```
+
+## Example
+
+### Input (sample.dbml)
+
+```dbml
+Table users {
+  id int [pk]
+  username varchar
+  email varchar
+  created_at timestamp
+}
+
+Table posts {
+  id int [pk]
+  title varchar
+  body text
+  user_id int [ref: > users.id]
+  created_at timestamp
+}
+```
+
+### Output (sample.mmd)
+
+```
+erDiagram
+    users {
+        int id PK
+        varchar username
+        varchar email
+        timestamp created_at
+    }
+    
+    posts {
+        int id PK
+        varchar title
+        text body
+        int user_id FK
+        timestamp created_at
+    }
+    
+    posts ||--o{ users : "user_id"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/ernie-brodeur-goxlabs/dbml2mmd>.
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "dbml2mmd"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/dbml2mmd

@@ -0,0 +1,381 @@
+#!/usr/bin/env ruby
+
+require "dbml2mmd"
+#!/usr/bin/env ruby
+
+require 'json'
+begin
+  require 'slop'
+rescue LoadError
+  puts "Error: slop gem is required for CLI handling."
+  puts "Please install it using: gem install slop"
+  exit 1
+end
+
+# Try to load dbml gem if available
+USING_GEM = begin
+  require 'dbml'
+  true
+rescue LoadError
+  false
+end
+
+class DBMLParser
+  def self.parse(content)
+    if USING_GEM
+      # Use the dbml gem if available
+      parser = DBML::Parser.new
+      result = parser.parse(content)
+      convert_to_standard_format(result)
+    else
+      # Simple custom DBML parser implementation
+      parse_dbml(content)
+    end
+  end
+  
+  # Convert dbml gem output to standard format
+  def self.convert_to_standard_format(result)
+    standard = { tables: [], refs: [] }
+    
+    # Process tables
+    result.tables.each do |table|
+      fields = table.columns.map do |column|
+        {
+          name: column.name,
+          type: column.type,
+          attributes: column.settings&.join(',')
+        }
+      end
+      
+      standard[:tables] << {
+        name: table.name,
+        fields: fields
+      }
+    end
+    
+    # Process references
+    result.refs.each do |ref|
+      endpoint1 = ref.endpoints.first
+      endpoint2 = ref.endpoints.last
+      
+      standard[:refs] << {
+        from: { table: endpoint1.tableName, field: endpoint1.columnName },
+        to: { table: endpoint2.tableName, field: endpoint2.columnName },
+        type: determine_relationship_type(ref)
+      }
+    end
+    
+    standard
+  end
+  
+  # Determine relationship type from dbml gem reference
+  def self.determine_relationship_type(ref)
+    endpoint1 = ref.endpoints.first
+    endpoint2 = ref.endpoints.last
+    
+    if endpoint1.relation == '1' && endpoint2.relation == '1'
+      'one_to_one'
+    elsif endpoint1.relation == '1' && endpoint2.relation == '*'
+      'one_to_many'
+    elsif endpoint1.relation == '*' && endpoint2.relation == '1'
+      'many_to_one'
+    elsif endpoint1.relation == '*' && endpoint2.relation == '*'
+      'many_to_many'
+    else
+      'one_to_one' # Default
+    end
+  end
+
+  # Simple DBML parser implementation
+  def self.parse_dbml(content)
+    result = { tables: [], refs: [] }
+    
+    # Extract tables
+    table_blocks = content.scan(/Table\s+(\w+)\s*\{([^}]*)\}/m)
+    table_blocks.each do |table_name, table_content|
+      fields = []
+      field_lines = table_content.strip.split("\n")
+      field_lines.each do |line|
+        line = line.strip
+        next if line.empty?
+        
+        # Basic field parsing
+        if line =~ /^(\w+)\s+(\w+)(?:\s+\[(.*)\])?/
+          field_name = $1
+          field_type = $2
+          attributes = $3
+          
+          fields << {
+            name: field_name,
+            type: field_type,
+            attributes: attributes
+          }
+        end
+      end
+      
+      result[:tables] << {
+        name: table_name,
+        fields: fields
+      }
+    end
+    
+    # Extract references
+    ref_lines = content.scan(/Ref:\s*(.*?)$/m)
+    ref_lines.each do |ref_line|
+      ref_line = ref_line[0].strip
+      if ref_line =~ /(\w+)\.(\w+)\s*([<>])\s*(\w+)\.(\w+)/
+        from_table = $1
+        from_field = $2
+        type_symbol = $3
+        to_table = $4
+        to_field = $5
+        
+        # Determine relationship type based on symbol
+        rel_type = case type_symbol
+                   when '>' then 'many_to_one'
+                   when '<' then 'one_to_many'
+                   else 'one_to_one'
+                   end
+        
+        result[:refs] << {
+          from: { table: from_table, field: from_field },
+          to: { table: to_table, field: to_field },
+          type: rel_type
+        }
+      end
+    end
+    
+    result
+  end
+end
+
+class Dbml2Mermaid
+  def initialize(options = {})
+    @options = options
+    @theme = options[:theme] || 'default'
+  end
+
+  def convert(dbml_content)
+    # Parse DBML content
+    dbml = DBMLParser.parse(dbml_content)
+    tables = dbml[:tables] || []
+    refs = dbml[:refs] || []
+    
+    # Filter tables if specified
+    if @options[:only_tables] && !@options[:only_tables].empty?
+      table_list = @options[:only_tables].split(',').map(&:strip)
+      tables = tables.select { |table| table_list.include?(table[:name]) }
+      # Only keep references between included tables
+      refs = refs.select do |ref| 
+        table_list.include?(ref[:from][:table]) && table_list.include?(ref[:to][:table])
+      end
+    end
+
+    # Generate Mermaid ERD
+    mermaid = ["erDiagram"]
+    
+    # Add tables and their fields
+    tables.each do |table|
+      table_fields = []
+      table[:fields].each do |field|
+        field_type = field[:type].to_s.gsub(/\s+/, "")
+        
+        # Check for primary key attribute and format appropriately
+        is_pk = field[:attributes]&.to_s&.include?('primary key')
+        is_fk = refs.any? { |ref| ref[:from][:table] == table[:name] && ref[:from][:field] == field[:name] }
+        
+        field_annotation = []
+        field_annotation << "PK" if is_pk
+        field_annotation << "FK" if is_fk
+        
+        annotation_str = field_annotation.empty? ? "" : " #{field_annotation.join(',')}"
+        
+        # Format the field with proper spacing
+        table_fields << "    #{field[:name]} #{field_type}#{annotation_str}"
+      end
+      
+      mermaid << "  #{table[:name]} {"
+      mermaid.concat(table_fields)
+      mermaid << "  }"
+    end
+    
+    # Add relationships with proper labels
+    refs.each do |ref|
+      from_table = ref[:from][:table]
+      to_table = ref[:to][:table]
+      relationship_type = get_relationship_type(ref[:type])
+      
+      # Create a more descriptive label if available
+      label = "\"#{ref[:from][:field]} -> #{ref[:to][:field]}\""
+      if ref[:name]
+        label = "\"#{ref[:name]}: #{ref[:from][:field]} -> #{ref[:to][:field]}\""
+      end
+      
+      mermaid << "  #{from_table} #{relationship_type} #{to_table} : #{label}"
+    end
+    
+    # Add a header comment with generation info and theme
+    theme_config = get_theme_config(@theme)
+    header = [
+      "%%{init: #{theme_config}}%%",
+      "% Generated by dbml2mmd on #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}",
+      "% https://mermaid.js.org/syntax/entityRelationshipDiagram.html"
+    ]
+    
+    # Return the full diagram
+    (header + [mermaid.join("\n")]).join("\n")
+  end
+  
+  def output_html
+    return nil unless @options[:html_output]
+    
+    <<-HTML
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Database Diagram</title>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+  <style>
+    body { font-family: sans-serif; margin: 20px; }
+    .mermaid { margin: 20px auto; }
+  </style>
+</head>
+<body>
+  <h1>Database Diagram</h1>
+  <p>Generated on #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}</p>
+  <div class="mermaid">
+#{@last_output}
+  </div>
+  <script>
+    mermaid.initialize({ startOnLoad: true });
+  </script>
+</body>
+</html>
+    HTML
+  end
+  
+  private
+  
+  def get_relationship_type(type)
+    case type
+    when 'one_to_one'
+      "||--||"
+    when 'one_to_many'
+      "||--o{"
+    when 'many_to_one'
+      "}o--||"
+    when 'many_to_many'
+      "}o--o{"
+    else
+      "--"
+    end
+  end
+  
+  def get_theme_config(theme)
+    case theme
+    when 'dark'
+      "{'theme': 'dark', 'themeVariables': { 'primaryColor': '#2A2A2A', 'primaryBorderColor': '#777', 'primaryTextColor': '#DDD' }}"
+    when 'neutral'
+      "{'theme': 'neutral', 'themeVariables': { 'primaryColor': '#f4f4f4', 'primaryBorderColor': '#888', 'primaryTextColor': '#333' }}"
+    when 'forest'
+      "{'theme': 'forest', 'themeVariables': { 'primaryColor': '#e6f5e6', 'primaryBorderColor': '#4d994d', 'primaryTextColor': '#1a331a' }}"
+    else # default theme
+      "{'theme': 'default', 'themeVariables': { 'primaryColor': '#f4f4f4', 'primaryBorderColor': '#aaa', 'primaryTextColor': '#333' }}"
+    end
+  end
+end
+
+# Parse command-line arguments with Slop
+begin
+  opts = Slop.parse do |o|
+    o.banner = "Usage: dbml2mmd [options] [input_file]"
+    
+    o.string '-o', '--output', 'Output to file instead of stdout'
+    o.bool '-h', '--help', 'Show this help message', default: false
+    o.string '-t', '--theme', 'Mermaid theme (default, dark, neutral, forest)', default: 'default'
+    o.bool '--html', 'Generate HTML output with embedded Mermaid viewer', default: false
+    o.string '--only', 'Only include specific tables (comma-separated list)'
+    o.bool '-v', '--verbose', 'Enable verbose output', default: false
+    
+    o.on '--version', 'Print the version' do
+      puts "DBML to Mermaid Converter v0.1.0"
+      exit
+    end
+  end
+
+  # Show help by default when no arguments are provided
+  if (ARGV.empty? && STDIN.tty?) || opts.help?
+    puts opts
+    puts "\nExamples:"
+    puts "  dbml2mmd input.dbml                    # Convert file and output to stdout"
+    puts "  dbml2mmd -o output.mmd input.dbml      # Convert file and save to output.mmd"
+    puts "  dbml2mmd --html -o output.html input.dbml  # Generate HTML with Mermaid viewer"
+    puts "  dbml2mmd --theme dark input.dbml       # Use dark theme for diagram"
+    puts "  dbml2mmd --only users,posts input.dbml # Only include specific tables"
+    puts "  cat input.dbml | dbml2mmd              # Read from stdin and output to stdout"
+    
+    if USING_GEM
+      puts "\nUsing dbml gem for DBML parsing."
+    else
+      puts "\nUsing built-in DBML parser (limited functionality)."
+      puts "For full DBML support, install the dbml gem: gem install dbml"
+    end
+    
+    exit
+  end
+  
+  # Get input from file or stdin
+  input = nil
+  if ARGV.empty?
+    input = ARGF.read
+  else
+    input = File.read(ARGV[0])
+  rescue Errno::ENOENT
+    puts "Error: File not found: #{ARGV[0]}"
+    exit 1
+  end
+  
+  # Setup converter options
+  converter_options = {
+    theme: opts[:theme],
+    html_output: opts[:html],
+    only_tables: opts[:only],
+    verbose: opts[:verbose]
+  }
+  
+  # Print verbose info if enabled
+  if opts[:verbose]
+    puts "Input source: #{ARGV.empty? ? 'STDIN' : ARGV[0]}"
+    puts "Using DBML gem: #{USING_GEM}"
+    puts "Theme: #{opts[:theme]}"
+    puts "HTML output: #{opts[:html]}"
+    puts "Filtering tables: #{opts[:only] ? opts[:only] : 'No'}"
+  end
+  
+  # Convert DBML to Mermaid
+  converter = Dbml2Mermaid.new(converter_options)
+  mermaid = converter.convert(input)
+  converter.instance_variable_set(:@last_output, mermaid)
+  
+  # Output result
+  if opts[:output]
+    if opts[:html]
+      File.write(opts[:output], converter.output_html)
+    else
+      File.write(opts[:output], mermaid)
+    end
+    puts "Output written to #{opts[:output]}"
+  else
+    puts mermaid
+  end
+  
+rescue Slop::Error => e
+  puts "Error: #{e.message}"
+  puts opts
+  exit 1
+rescue => e
+  puts "Error: #{e.message}"
+  puts opts
+  exit 1
+end

data/lib/dbml2mmd/version.rb

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

data/lib/dbml2mmd.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "dbml2mmd/version"
+
+module Dbml2mmd
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: dbml2mmd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ernie Brodeur
+bindir: exe
+cert_chain: []
+date: 2025-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: dbml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: A tool to convert Database Markup Language (DBML) schemas to Mermaid
+  Entity Relationship Diagrams (ERD) for visualization
+email:
+- ebrodeur@ujami.net
+executables:
+- dbml2mmd
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/console
+- bin/setup
+- exe/dbml2mmd
+- lib/dbml2mmd.rb
+- lib/dbml2mmd/version.rb
+homepage: https://github.com/ebrodeur/dbml2mmd
+licenses:
+- GPL-3.0
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ebrodeur/dbml2mmd
+  source_code_uri: https://github.com/ebrodeur/dbml2mmd
+  changelog_uri: https://github.com/ebrodeur/dbml2mmd/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Convert DBML database schemas to Mermaid ERD diagrams
+test_files: []