rails-erd 1.7.1 → 2.0.0

data/lib/rails_erd/domain/attribute.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 #--
 module RailsERD
@@ -49,7 +49,7 @@ module RailsERD
       # The type of the attribute, equal to the Rails migration type. Can be any
       # of +:string+, +:integer+, +:boolean+, +:text+, etc.
       def type
-        column.type or column.sql_type.downcase.to_sym
+        !RailsERD.options[:native_types] and column.type or column.sql_type.downcase.to_sym
       end
 
       # Returns +true+ if this attribute is a content column, that is, if it
@@ -77,9 +77,18 @@ module RailsERD
       # Returns +true+ if this attribute is used as a foreign key for any
       # relationship.
       def foreign_key?
-        @domain.relationships_by_entity_name(@model.name).map(&:associations).flatten.map { |associaton|
-          associaton.send(Domain.foreign_key_method_name)
-        }.include?(name)
+        @domain
+          .relationships_by_entity_name(@model.name)
+          .map(&:associations)
+          .flatten
+          .map do |associaton|
+            result = associaton.send(Domain.foreign_key_method_name)
+            if result.respond_to?(:to_ary)
+              result.join("_").to_sym
+            else
+              result.to_sym
+            end
+          end.include?(name.to_sym)
       end
 
       # Returns +true+ if this attribute is used for single table inheritance.
@@ -120,6 +129,7 @@ module RailsERD
       # <tt>:boolean, :null => false</tt>:: boolean *
       def type_description
         type.to_s.dup.tap do |desc|
+          desc << "[]" if column.respond_to?(:array?) && column.array?
           desc << " #{limit_description}" if limit_description
           desc << " ∗" if mandatory? && !primary_key? # Add a hair space + low asterisk (Unicode characters)
           desc << " U" if unique? && !primary_key? && !foreign_key? # Add U if unique but non-key

data/lib/rails_erd/domain/entity.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsERD
   class Domain
     # Entities represent your Active Record models. Entities may be connected
@@ -38,6 +40,10 @@ module RailsERD
         @domain, @name, @model = domain, name, model
       end
 
+      def label
+        RailsERD.options[:table_names] ? model.table_name : name
+      end
+
       # Returns an array of attributes for this entity.
       def attributes
         @attributes ||= generalized? ? [] : Attribute.from_model(domain, model)

data/lib/rails_erd/domain/relationship/cardinality.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsERD
   class Domain
     class Relationship

data/lib/rails_erd/domain/relationship.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 require "active_support/core_ext/module/delegation"
 require "rails_erd/domain/relationship/cardinality"

data/lib/rails_erd/domain/specialization.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsERD
   class Domain
     # Describes the specialization of an entity. Specialized entities correspond

data/lib/rails_erd/domain.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails_erd"
 require "rails_erd/domain/attribute"
 require "rails_erd/domain/entity"
@@ -65,7 +67,9 @@ module RailsERD
 
     # Returns all relationships in your domain model.
     def relationships
-      @relationships ||= Relationship.from_associations(self, associations)
+      @relationships ||= Relationship.from_associations(self, associations).select do |relationship|
+        relationship.source && relationship.destination
+      end
     end
 
     # Returns all specializations in your domain model.
@@ -120,7 +124,46 @@ module RailsERD
     end
 
     def models
-      @models ||= @source_models.select { |model| check_model_validity(model) }.reject { |model| check_habtm_model(model) }
+      @models ||= @source_models
+                    .reject { |model| tableless_rails_models.include?(model) }
+                    .select { |model| check_model_validity(model) }
+                    .reject { |model| check_habtm_model(model) }
+    end
+
+    # Returns Rails model classes defined in the app
+    def rails_models
+      %w(
+        ActionMailbox::InboundEmail
+        ActionText::EncryptedRichText
+        ActionText::RichText
+        ActiveStorage::Attachment
+        ActiveStorage::Blob
+        ActiveStorage::VariantRecord
+        SolidCable::Message
+        SolidCache::Entry
+        SolidQueue::BlockedExecution
+        SolidQueue::ClaimedExecution
+        SolidQueue::Execution
+        SolidQueue::FailedExecution
+        SolidQueue::Job
+        SolidQueue::Pause
+        SolidQueue::Process
+        SolidQueue::ReadyExecution
+        SolidQueue::RecurringExecution
+        SolidQueue::RecurringTask
+        SolidQueue::ScheduledExecution
+        SolidQueue::Semaphore
+      ).map { |model| Object.const_get(model) rescue nil }.compact
+    end
+
+    def tableless_rails_models
+      @tableless_rails_models ||= begin
+        if defined? Rails
+          rails_models.reject{ |model| model.table_exists? }
+        else
+          []
+        end
+      end
     end
 
     def associations
@@ -138,7 +181,13 @@ module RailsERD
         raise "table #{model.table_name} does not exist"
       end
     rescue => e
-      warn "Ignoring invalid model #{model.name} (#{e.message})"
+      warn "Ignoring invalid model #{model.name} (#{e.message})" unless excluded_model?(model)
+    end
+
+    def excluded_model?(model)
+      return false unless options.exclude.present?
+
+      [options.exclude].flatten.map(&:to_sym).include?(model.name.to_sym)
     end
 
     def check_association_validity(association)
@@ -152,7 +201,20 @@ module RailsERD
         entity_by_name(entity_name) or raise "model #{entity_name} exists, but is not included in domain"
       end
     rescue => e
-      warn "Ignoring invalid association #{association_description(association)} (#{e.message})"
+      warn "Ignoring invalid association #{association_description(association)} (#{e.message})" unless excluded_association?(association)
+    end
+
+    def excluded_association?(association)
+      return false unless options.exclude.present?
+
+      excluded_names = [options.exclude].flatten.map(&:to_sym)
+
+      # Suppress warning if either the source model or target model is excluded
+      excluded_names.include?(association.active_record.name.to_sym) ||
+        (association.klass.name && excluded_names.include?(association.klass.name.to_sym))
+    rescue NameError
+      # If we can't determine the target class, check only the source model
+      excluded_names.include?(association.active_record.name.to_sym)
     end
 
     def check_polymorphic_association_validity(association)

data/lib/rails_erd/railtie.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module RailsERD
-  # Rails ERD integrates with Rails 3. If you add it to your +Gemfile+, you
+  # Rails ERD integrates with Rails. If you add it to your +Gemfile+, you
   # will gain a Rake task called +erd+, which you can use to generate diagrams
   # of your domain model.
   class Railtie < Rails::Railtie

data/lib/rails_erd/tasks.rake

@@ -1,5 +1,3 @@
-require 'graphviz/utils'
-
 module ErdRakeHelper
   def say(message)
     puts message unless Rake.application.options.silent
@@ -8,10 +6,18 @@ end
 
 namespace :erd do
   task :check_dependencies do
-    include GraphViz::Utils
-    unless find_executable("dot", nil)
-      raise "Unable to find GraphViz's \"dot\" executable. Please " \
-            "visit https://voormedia.github.io/rails-erd/install.html for installation instructions."
+    if RailsERD.options.generator == :graphviz
+      begin
+        require 'graphviz/utils'
+        include GraphViz::Utils
+        unless find_executable("dot", nil)
+          raise "Unable to find GraphViz's \"dot\" executable. Please " \
+                "visit https://voormedia.github.io/rails-erd/install.html for installation instructions."
+        end
+      rescue LoadError
+        raise "The ruby-graphviz gem is required for Graphviz output. " \
+              "Add `gem 'ruby-graphviz'` to your Gemfile, or use `generator=mermaid` instead."
+      end
     end
   end
 
@@ -58,13 +64,22 @@ namespace :erd do
     raise "Active Record was not loaded." unless defined? ActiveRecord
   end
 
-  task :generate => [:check_dependencies, :options, :load_models] do
+  task :generate => [:options, :check_dependencies, :load_models] do
     include ErdRakeHelper
 
     say "Generating Entity-Relationship Diagram for #{ActiveRecord::Base.descendants.length} models..."
 
-    require "rails_erd/diagram/graphviz"
-    file = RailsERD::Diagram::Graphviz.create
+    file = case RailsERD.options.generator
+    when :mermaid
+      require "rails_erd/diagram/mermaid"
+      RailsERD::Diagram::Mermaid.create
+    when :graphviz
+      require "rails_erd/diagram/graphviz"
+      RailsERD::Diagram::Graphviz.create
+    else
+      raise "Unknown generator: #{RailsERD.options.generator}"
+    end
+
 
     say "Done! Saved diagram to ./#{file}"
   end

data/lib/rails_erd/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module RailsERD
-  VERSION = "1.7.1"
+  VERSION = "2.0.0"
   BANNER  = "RailsERD #{VERSION}"
 end

data/lib/rails_erd.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/ordered_options"
 require "rails_erd/railtie" if defined? Rails
 require "rails_erd/config"
@@ -36,14 +38,16 @@ module RailsERD
 
     def default_options
       ActiveSupport::OrderedOptions[
+        :generator, :mermaid,
         :attributes, :content,
         :disconnected, true,
         :filename, "erd",
-        :filetype, :pdf,
+        :filetype, :mmd,
         :fonts, {},
         :indirect, true,
         :inheritance, false,
         :markup, true,
+        :mermaid_style, :erdiagram,
         :notation, :simple,
         :orientation, :horizontal,
         :polymorphism, false,
@@ -55,6 +59,8 @@ module RailsERD
         :only_recursion_depth, nil,
         :prepend_primary, false,
         :cluster, false,
+        :table_names, false,
+        :native_types, false
       ]
     end
 

data/test/unit/cli_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+require "rails_erd/cli"
+
+class CLITest < ActiveSupport::TestCase
+  def setup
+    RailsERD.options.filetype = :dot
+    RailsERD.options.warn = false
+  end
+
+  # Generator selection ========================================================
+  test "CLI should use mermaid generator by default" do
+    require "rails_erd/diagram/mermaid"
+    cli = RailsERD::CLI.new(Dir.pwd, {})
+    assert_equal RailsERD::Diagram::Mermaid, cli.send(:generator)
+  end
+
+  test "CLI should use graphviz generator when generator option is graphviz symbol" do
+    cli = RailsERD::CLI.new(Dir.pwd, { generator: :graphviz })
+    assert_equal RailsERD::Diagram::Graphviz, cli.send(:generator)
+  end
+
+  test "CLI should use mermaid generator when generator option is mermaid symbol" do
+    require "rails_erd/diagram/mermaid"
+    cli = RailsERD::CLI.new(Dir.pwd, { generator: :mermaid })
+    assert_equal RailsERD::Diagram::Mermaid, cli.send(:generator)
+  end
+
+  # Option parsing (SYMBOL_OPTIONS conversion) =================================
+  test "CLI start should convert generator string to symbol" do
+    # Simulate what Choice.choices returns (strings)
+    Choice.stubs(:choices).returns({ "generator" => "mermaid" })
+    Choice.stubs(:rest).returns([])
+
+    # Capture the options passed to new
+    captured_options = nil
+    RailsERD::CLI.stubs(:new).with do |path, options|
+      captured_options = options
+      true
+    end.returns(stub(start: nil))
+
+    RailsERD::CLI.start
+
+    assert_equal :mermaid, captured_options[:generator]
+  end
+
+  test "CLI start should convert mermaid_style string to symbol" do
+    Choice.stubs(:choices).returns({ "mermaid_style" => "erdiagram" })
+    Choice.stubs(:rest).returns([])
+
+    captured_options = nil
+    RailsERD::CLI.stubs(:new).with do |path, options|
+      captured_options = options
+      true
+    end.returns(stub(start: nil))
+
+    RailsERD::CLI.start
+
+    assert_equal :erdiagram, captured_options[:mermaid_style]
+  end
+
+  test "CLI start should convert filetype string to symbol" do
+    Choice.stubs(:choices).returns({ "filetype" => "pdf" })
+    Choice.stubs(:rest).returns([])
+
+    captured_options = nil
+    RailsERD::CLI.stubs(:new).with do |path, options|
+      captured_options = options
+      true
+    end.returns(stub(start: nil))
+
+    RailsERD::CLI.start
+
+    assert_equal :pdf, captured_options[:filetype]
+  end
+end

data/test/unit/config_test.rb

@@ -8,6 +8,13 @@ class ConfigTest < ActiveSupport::TestCase
     assert_equal expected_hash, RailsERD::Config.load
   end
 
+  test "load_config_file should return blank hash when config file is empty" do
+    set_local_config_file_to("erdconfig.empty")
+
+    expected_hash = {}
+    assert_equal expected_hash, RailsERD::Config.load
+  end
+
   test "load_config_gile should return a hash from USER_WIDE_CONFIG_FILE when only USER_WIDE_CONFIG_FILE exists." do
     set_user_config_file_to("erdconfig.example")
 

data/test/unit/domain_test.rb

@@ -127,21 +127,16 @@ class DomainTest < ActiveSupport::TestCase
   end
 
   test "relationships should count relationship between same models with distinct foreign key seperately" do
-    # TODO: Once we drop Rails 3.2 support, we _should_ be able to drop the
-    #   :respond_to? check
-    #
-    if respond_to? :skip
-      skip("multiple edges between the same objects can cause segfaults in some versions of Graphviz")
+    skip("multiple edges between the same objects can cause segfaults in some versions of Graphviz")
 
-      create_model "Foo", :bar => :references, :special_bar => :references do
-        belongs_to :bar
-      end
-      create_model "Bar" do
-        has_many :foos, :foreign_key => :special_bar_id
-      end
-
-      assert_equal [Domain::Relationship] * 2, Domain.generate.relationships.collect(&:class)
+    create_model "Foo", :bar => :references, :special_bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar" do
+      has_many :foos, :foreign_key => :special_bar_id
     end
+
+    assert_equal [Domain::Relationship] * 2, Domain.generate.relationships.collect(&:class)
   end
 
   test "relationships should use model name first in alphabet as source for many to many relationships" do
@@ -283,4 +278,14 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_match(/Ignoring invalid model Foo \(table foos does not exist\)/, output)
   end
+
+  test "entities should not output a warning when a Rails model table does not exist" do
+    module ActionMailbox; end
+
+    Object.const_set :InboundEmail, ActionMailbox
+    output = collect_stdout do
+      Domain.generate.entities
+    end
+    assert_equal "", output
+  end
 end

data/test/unit/graphviz_test.rb

@@ -193,7 +193,9 @@ class GraphvizTest < ActiveSupport::TestCase
 
   test "generate should add set value for fontname attribute" do
     create_simple_domain
-    assert_equal '"Arial Bold"', diagram(fonts: {bold: "Arial Bold"}).graph.graph[:fontname].to_s
+    # Use OS-appropriate font name (macOS uses PostScript names like "Arial BoldMT")
+    expected_font = RailsERD::Config.font_names_based_on_os[:bold]
+    assert_equal "\"#{expected_font}\"", diagram(fonts: {bold: expected_font}).graph.graph[:fontname].to_s
   end
 
   test "generate should add default value for splines attribute" do
@@ -314,21 +316,16 @@ class GraphvizTest < ActiveSupport::TestCase
   end
 
   test "generate should create edge for each relationship" do
-    # TODO: Once we drop Rails 3.2 support, we _should_ be able to drop the
-    #   :respond_to? check
-    #
-    if respond_to? :skip
-      skip("multiple edges between the same objects can cause segfaults in some versions of Graphviz")
-
-      create_model "Foo", :bar => :references do
-        belongs_to :bar
-      end
-      create_model "Bar", :foo => :references do
-        belongs_to :foo
-      end
+    skip("multiple edges between the same objects can cause segfaults in some versions of Graphviz")
 
-      assert_equal [["m_Bar", "m_Foo"], ["m_Foo", "m_Bar"]], find_dot_node_pairs(diagram).sort
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar", :foo => :references do
+      belongs_to :foo
     end
+
+    assert_equal [["m_Bar", "m_Foo"], ["m_Foo", "m_Bar"]], find_dot_node_pairs(diagram).sort
   end
 
   test "generate should create edge to polymorphic entity if polymorphism is true" do