rails-erd 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dadf622a2d2bcae2e4961d23b1f86647b7eaf4e68ae062dad5a18050b2fc935
-  data.tar.gz: 72115211691f90710ccdfea75c6b8456bae393cc1794b73727006ee3ec7475af
+  metadata.gz: 4d47dd705b783be29e06d39d8bea92d6c5ac8019fba658e0279287b2197938d3
+  data.tar.gz: 1417646a7d2731ad2964e9cbac400cb3b2325f765ba1db610b44f28ffe03f699
 SHA512:
-  metadata.gz: f19813191fc9a1258053cab237535fb5358e2a804af4bf394bcae0eb1e2b743c1d48c284d100b2044bed76aa57e8f95cd998379e84fc16de9cecbf452d29d816
-  data.tar.gz: b77b4b3e57436b9a32fe92cfec304aa35c8f094fc0c00d615f01c394fae6680f899eab1f548d50986a61534372b48b661d656638502ad1bdad5bc4da3757c139
+  metadata.gz: cde6a9b96a0d3e5c03ccbed1c3e04e37d27efb3a37d2a09e1a5ff298cbb4e9ec3148065c551efe8da349315d7601420b3b98bccf049f4c83b782863a6a13f495
+  data.tar.gz: 5d53400f939b341b02becb90a5b4b413d4556a0fc36ef856d4c831d13ccc343ab0fd48772c8245ebedcdcdfee028068d51b1a09027ae809614c568bf19506505

data/README.md

@@ -70,6 +70,7 @@ sort: true
 warn: true
 title: true
 exclude: null
+exclude_attributes: null
 only: null
 only_recursion_depth: null
 prepend_primary: false
@@ -77,6 +78,32 @@ cluster: false
 splines: spline
 ```
 
+### Hiding attributes for specific models
+
+While `attributes: false` hides attributes for *every* model, `exclude_attributes`
+lets you hide attributes for individual models without affecting the others. Map a
+model name to `true` to hide all of its attributes, or to a list of attribute names
+to hide only those:
+
+```yaml
+exclude_attributes:
+  BigTable: true            # hide all attributes for BigTable
+  User:                     # hide only these attributes for User
+    - password_digest
+    - remember_token
+```
+
+From the command line, pass a comma separated list where each entry is either
+`Model` (hide all of its attributes) or `Model.attribute` (hide a single one):
+
+```bash
+# rake task (bare key=value)
+bundle exec rake erd exclude_attributes="BigTable,User.password_digest,User.remember_token"
+
+# erd binary (flags require the -- prefix)
+bundle exec erd --exclude_attributes="BigTable,User.password_digest,User.remember_token"
+```
+
 You can also customize fonts (useful if the defaults aren't available on your system):
 
 ```yaml

data/lib/rails_erd/cli.rb

@@ -72,6 +72,11 @@ Choice.options do
     desc "Filter to exclude listed models in diagram."
   end
 
+  option :exclude_attributes do
+    long "--exclude_attributes=MODEL[.ATTRIBUTE],..."
+    desc "Hide attributes per model. Use Model to hide all its attributes or Model.attribute to hide one, e.g. BigTable,User.password_digest."
+  end
+
   option :sort do
     long "--sort=BOOLEAN"
     desc "Sort attribute list alphabetically"

data/lib/rails_erd/config.rb

@@ -73,6 +73,11 @@ module RailsERD
       when :only, :exclude
         Array(value).join(",").split(",").map { |v| v.strip }
 
+      # nil | { <string> => true | [<string>] }
+      when :exclude_attributes
+        require "rails_erd/diagram"
+        RailsERD::Diagram.normalize_exclude_attributes(value)
+
       # true | false
       when :disconnected, :indirect, :inheritance, :markup, :polymorphism,
            :warn, :cluster

data/lib/rails_erd/diagram/mermaid.rb

@@ -20,7 +20,8 @@ module RailsERD
       each_entity do |entity, attributes|
         if er_diagram?
           # Build entity block as a single string to avoid uniq issues with closing braces
-          entity_lines = ["\t#{entity} {"]
+          quoted_entity = quote_entity_name(entity)
+          entity_lines = ["\t#{quoted_entity} {"]
           attributes.each do |attr|
             key_marker = attribute_key_marker(attr)
             entity_lines << "\t\t#{attr.type} #{attr.name}#{key_marker}"
@@ -39,7 +40,7 @@ module RailsERD
         from, to = specialization.generalized, specialization.specialized
         if er_diagram?
           # erDiagram doesn't have a direct polymorphic notation, use inheritance-like
-          graph << "\t#{from.name} ||--o{ #{to.name} : \"specializes\""
+          graph << "\t#{quote_entity_name(from.name)} ||--o{ #{quote_entity_name(to.name)} : \"specializes\""
         else
           graph << "\t<<polymorphic>> `#{specialization.generalized}`"
           graph << "\t #{from.name} <|-- #{to.name}"
@@ -51,14 +52,14 @@ module RailsERD
         next unless from && to
 
         if er_diagram?
-          graph << "\t#{from.name} #{er_relation_notation(relationship)} #{to.name} : \"\""
+          graph << "\t#{quote_entity_name(from.name)} #{er_relation_notation(relationship)} #{quote_entity_name(to.name)} : \"\""
 
           from.children.each do |child|
-            graph << "\t#{child.name} #{er_relation_notation(relationship)} #{to.name} : \"\""
+            graph << "\t#{quote_entity_name(child.name)} #{er_relation_notation(relationship)} #{quote_entity_name(to.name)} : \"\""
           end
 
           to.children.each do |child|
-            graph << "\t#{from.name} #{er_relation_notation(relationship)} #{child.name} : \"\""
+            graph << "\t#{quote_entity_name(from.name)} #{er_relation_notation(relationship)} #{quote_entity_name(child.name)} : \"\""
           end
         else
           graph << "\t`#{from.name}` #{relation_arrow(relationship)} `#{to.name}`"
@@ -92,6 +93,17 @@ module RailsERD
         options[:mermaid_style] == :erdiagram || options[:mermaid_style] == :er
       end
 
+      # Quote entity names that contain special characters (like :: for namespaces)
+      # Mermaid erDiagram requires double quotes for names with special characters
+      def quote_entity_name(name)
+        name = name.to_s
+        if name.include?("::")
+          %("#{name}")
+        else
+          name
+        end
+      end
+
       # erDiagram relationship notation using crow's foot
       # Format: left_cardinality--right_cardinality
       # Cardinality markers:

data/lib/rails_erd/diagram.rb

@@ -55,6 +55,14 @@ module RailsERD
   # attributes:: Selects which attributes to display. Can be any combination of
   #              +:content+, +:primary_keys+, +:foreign_keys+, +:timestamps+, or
   #              +:inheritance+.
+  # exclude_attributes:: Hides attributes on a per-model basis, without affecting
+  #                      other models. Accepts a hash that maps model names to
+  #                      either +true+ (hide all attributes for that model) or a
+  #                      list of attribute names to hide. From the command line it
+  #                      can also be given as a comma separated string where each
+  #                      entry is either +Model+ (hide all attributes) or
+  #                      +Model.attribute+ (hide a single attribute), for example
+  #                      <tt>exclude_attributes="BigTable,User.password_digest"</tt>.
   # disconnected:: Set to +false+ to exclude entities that are not connected to other
   #                entities. Defaults to +false+.
   # indirect:: Set to +false+ to exclude relationships that are indirect.
@@ -76,6 +84,38 @@ module RailsERD
         new(Domain.generate(options), options).create
       end
 
+      # Canonicalises the +exclude_attributes+ option into a hash that maps
+      # model names (as strings) to either +true+ (hide all attributes) or an
+      # array of attribute names to hide. Accepts several input shapes:
+      #
+      #   * a hash, e.g. <tt>{ "BigTable" => true, "User" => ["password_digest"] }</tt>
+      #     (values may be +true+/+"all"+ to hide every attribute, +false+/+nil+
+      #     to hide none, or a comma separated string / array of names);
+      #   * a string or array of <tt>Model</tt> / <tt>Model.attribute</tt>
+      #     entries, e.g. <tt>"BigTable,User.password_digest"</tt>.
+      def normalize_exclude_attributes(value)
+        return {} if value.nil? || value == false
+
+        if value.is_a?(Hash)
+          value.each_with_object({}) do |(model, attrs), result|
+            result[model.to_s] = normalize_exclude_attribute_value(attrs)
+          end
+        else
+          entries = Array(value).flat_map { |entry| entry.to_s.split(",") }
+          entries.each_with_object({}) do |entry, result|
+            model, attribute = entry.split(".", 2)
+            model = model.to_s.strip
+            next if model.empty?
+
+            if attribute.nil?
+              result[model] = true
+            elsif result[model] != true
+              (result[model] ||= []) << attribute.strip
+            end
+          end
+        end
+      end
+
       protected
 
       def setup(&block)
@@ -103,6 +143,16 @@ module RailsERD
       def callbacks
         @callbacks ||= Hash.new { proc {} }
       end
+
+      def normalize_exclude_attribute_value(attrs)
+        case attrs
+        when true then true
+        when false, nil then []
+        when "all", :all, "true" then true
+        else
+          Array(attrs).flat_map { |attr| attr.to_s.split(",") }.map(&:strip).reject(&:empty?)
+        end
+      end
     end
 
     # The options that are used to create this diagram.
@@ -205,13 +255,31 @@ module RailsERD
     end
 
     def filtered_attributes(entity)
+      excluded = excluded_attributes_for(entity)
+      return [] if excluded == :all
+
       entity.attributes.reject { |attribute|
+        # Hide attributes excluded for this specific model.
+        excluded.include?(attribute.name) or
         # Select attributes that satisfy the conditions in the :attributes option.
         !options.attributes or entity.specialized? or
         [*options.attributes].none? { |type| attribute.send(:"#{type.to_s.chomp('s')}?") }
       }
     end
 
+    # Returns the attribute exclusions configured for the given entity through
+    # the +exclude_attributes+ option. Returns +:all+ when every attribute
+    # should be hidden, or an array of attribute names otherwise.
+    def excluded_attributes_for(entity)
+      spec = normalized_exclude_attributes[entity.name]
+      return :all if spec == true
+      Array(spec)
+    end
+
+    def normalized_exclude_attributes
+      @normalized_exclude_attributes ||= self.class.normalize_exclude_attributes(options.exclude_attributes)
+    end
+
     def warn(message)
       puts "Warning: #{message}" if options.warn
     end

data/lib/rails_erd/domain.rb

@@ -210,11 +210,13 @@ module RailsERD
       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))
+      return true if excluded_names.include?(association.active_record.name.to_sym)
+
+      target_name = association.options[:polymorphic] ? association.class_name : association.klass.name
+      target_name && excluded_names.include?(target_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)
+      # If we can't determine the target class, the source model was already checked above
+      false
     end
 
     def check_polymorphic_association_validity(association)

data/lib/rails_erd/version.rb

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

data/lib/rails_erd.rb

@@ -55,6 +55,7 @@ module RailsERD
         :warn, true,
         :title, true,
         :exclude, nil,
+        :exclude_attributes, nil,
         :only, nil,
         :only_recursion_depth, nil,
         :prepend_primary, false,

data/test/test_helper.rb

@@ -2,6 +2,7 @@ require "rubygems"
 require "bundler/setup"
 require 'pry'
 require 'pry-nav'
+require 'tmpdir'
 
 require "active_record"
 
@@ -60,14 +61,17 @@ class ActiveSupport::TestCase
     superklass = args.first.kind_of?(Class) ? args.shift : ActiveRecord::Base
 
     names = full_name.split('::')
+    name = names.pop  # Remove and store the model name
 
-    parent_module = names[0..-1].inject(Object) do |parent,child|
-      parent = parent.const_set(child.to_sym, Module.new)
+    # Create namespace modules (all parts except the model name)
+    parent_module = names.inject(Object) do |parent, child|
+      if parent.const_defined?(child.to_sym, false)
+        parent.const_get(child.to_sym)
+      else
+        parent.const_set(child.to_sym, Module.new)
+      end
     end
 
-    parent_module ||= Object
-    name = names.last
-
     columns = args.first || {}
     klass = parent_module.const_set name.to_sym, Class.new(superklass)
     konstant = parent_module.const_get(name.to_sym)
@@ -173,6 +177,9 @@ class ActiveSupport::TestCase
       File.expand_path("../../examples/erdconfig.not_exists", __FILE__)
 
     RailsERD.options = RailsERD.default_options.merge(Config.load)
+
+    # Use temp directory for test output to avoid polluting the project root
+    RailsERD.options.filename = File.join(Dir.tmpdir, "rails_erd_test_erd")
   end
 
   def name_to_object_symbol_pairs(name)

data/test/unit/config_test.rb

@@ -122,6 +122,17 @@ class ConfigTest < ActiveSupport::TestCase
     assert_equal [:content, :primary_keys], normalize_value(:attributes, ["content", "primary_keys"])
   end
 
+  test "normalize_value should canonicalize a hash when key is :exclude_attributes." do
+    value = { "BigTable" => true, "User" => ["password_digest"] }
+    expected = { "BigTable" => true, "User" => ["password_digest"] }
+    assert_equal expected, normalize_value(:exclude_attributes, value)
+  end
+
+  test "normalize_value should parse a string when key is :exclude_attributes." do
+    expected = { "BigTable" => true, "User" => ["password_digest"] }
+    assert_equal expected, normalize_value(:exclude_attributes, "BigTable,User.password_digest")
+  end
+
   test "normalize_value should return hash with symbol keys when key is :fonts and value is a hash." do
     fonts_value = { "normal" => "Arial", "bold" => "Arial Bold", "italic" => "Arial Italic" }
     expected = {:normal => "Arial", :bold => "Arial Bold", :italic => "Arial Italic"}

data/test/unit/diagram_test.rb

@@ -358,4 +358,34 @@ class DiagramTest < ActiveSupport::TestCase
     Object.const_set :Whisky, Class.new(Beverage)
     assert_equal [], retrieve_attribute_lists(:inheritance => true)[Whisky].map(&:name)
   end
+
+  test "generate should hide all attributes for a model excluded with true" do
+    create_model "Book", :title => :string, :pages => :integer
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => { "Book" => true })
+    assert_equal [], attribute_lists[Book].map(&:name)
+    assert_equal %w{name}, attribute_lists[Author].map(&:name)
+  end
+
+  test "generate should hide only listed attributes for a model" do
+    create_model "Book", :title => :string, :subtitle => :string, :pages => :integer
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => { "Book" => ["subtitle"] })
+    assert_equal %w{pages title}, attribute_lists[Book].map(&:name).sort
+  end
+
+  test "generate should hide attributes for the listed model only" do
+    create_model "Book", :title => :string
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => { "Book" => ["title"] })
+    assert_equal [], attribute_lists[Book].map(&:name)
+    assert_equal %w{name}, attribute_lists[Author].map(&:name)
+  end
+
+  test "generate should accept exclude_attributes as a string" do
+    create_model "Book", :title => :string, :subtitle => :string
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => "Book.subtitle,Author")
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+    assert_equal [], attribute_lists[Author].map(&:name)
+  end
 end

data/test/unit/domain_test.rb

@@ -255,6 +255,19 @@ class DomainTest < ActiveSupport::TestCase
     assert_match(/polymorphic interface FooBar does not exist/, output)
   end
 
+  test "relationships should not crash when exclude is present and a polymorphic association's interface does not exist" do
+    create_model "Foo" do
+      has_many :bars, :as => :foo
+    end
+    create_model "Bar", :foobar => :references do
+      belongs_to :foo_bar, :polymorphic => true
+    end
+    output = collect_stdout do
+      Domain.generate(:exclude => ["Qux"]).relationships
+    end
+    assert_match(/polymorphic interface FooBar does not exist/, output)
+  end
+
   test "relationships should not warn when a bad association is encountered if warnings are disabled" do
     create_model "Foo" do
       has_many :flabs

data/test/unit/graphviz_test.rb

@@ -7,10 +7,6 @@ class GraphvizTest < ActiveSupport::TestCase
     RailsERD.options.warn     = false
   end
 
-  def teardown
-    FileUtils.rm Dir["erd*.*"] rescue nil
-  end
-
   def diagram(options = {})
     @diagram ||= Diagram::Graphviz.new(Domain.generate(options), options).tap do |diagram|
       diagram.generate
@@ -52,11 +48,8 @@ class GraphvizTest < ActiveSupport::TestCase
   # Diagram properties =======================================================
   test "file name should depend on file type" do
     create_simple_domain
-    begin
-      assert_equal "erd.svg", Diagram::Graphviz.create(:filetype => :svg)
-    ensure
-      FileUtils.rm "erd.svg" rescue nil
-    end
+    result = Diagram::Graphviz.create(:filetype => :svg)
+    assert result.end_with?(".svg"), "Expected filename to end with .svg, got: #{result}"
   end
 
   test "rank direction should be tb for horizontal orientation" do

data/test/unit/mermaid_test.rb

@@ -8,10 +8,6 @@ class MermaidTest < ActiveSupport::TestCase
     RailsERD.options.mermaid_style = :classdiagram
   end
 
-  def teardown
-    FileUtils.rm Dir["erd*.*"] rescue nil
-  end
-
   def diagram(options = {})
     @diagram ||= Diagram::Mermaid.new(Domain.generate(options), options).tap do |diagram|
       diagram.generate
@@ -27,13 +23,10 @@ class MermaidTest < ActiveSupport::TestCase
   end
 
   # Diagram properties =======================================================
-  test "file name should be mmd" do
+  test "file name should have mmd extension" do
     create_simple_domain
-    begin
-      assert_equal "erd.mmd", Diagram::Mermaid.create
-    ensure
-      FileUtils.rm "erd.mmd" rescue nil
-    end
+    result = Diagram::Mermaid.create
+    assert result.end_with?(".mmd"), "Expected filename to end with .mmd, got: #{result}"
   end
 
   test "direction should be top to bottom by default" do
@@ -385,4 +378,63 @@ class MermaidTest < ActiveSupport::TestCase
 
     assert result.include?("erDiagram")
   end
+
+  # Namespace tests (Issue #450) ================================================
+
+  test "classDiagram should handle namespaced model names" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram.graph
+
+    assert result.include?("classDiagram")
+    # Backticks should properly escape the namespace
+    assert result.any? { |line| line.include?("`Admin::Author`") }, "Should wrap namespaced entity in backticks"
+    assert result.any? { |line| line.include?("`Post`") && line.include?("`Admin::Author`") }, "Relationship should use backticks for both entities"
+  end
+
+  test "erDiagram should wrap namespaced model names in double quotes" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:mermaid_style => :erdiagram).graph.join("\n")
+
+    assert result.include?("erDiagram")
+    # Double quotes are required for entity names containing ::
+    assert result.include?('"Admin::Author"'), "Should wrap namespaced entity in double quotes, got: #{result}"
+    # Relationship line should also quote the namespaced entity (order may vary)
+    assert result.match?(/("Admin::Author".*--.*Post|Post.*--.*"Admin::Author")/), "Relationship should quote namespaced entity"
+  end
+
+  test "erDiagram should handle multiple namespaced models in relationships" do
+    create_module_model "Admin::User" do
+      has_many :posts, class_name: "Blog::Post"
+    end
+    create_module_model "Blog::Post", :admin_user => :references do
+      belongs_to :admin_user, class_name: "Admin::User"
+    end
+
+    result = diagram(:mermaid_style => :erdiagram).graph.join("\n")
+
+    assert result.include?('"Admin::User"'), "Should quote Admin::User"
+    assert result.include?('"Blog::Post"'), "Should quote Blog::Post"
+  end
+
+  test "erDiagram should quote namespaced entities in specialization relationships" do
+    create_model "Vehicle", :type => :string
+    # Create a namespaced subclass (STI)
+    create_module_model "Transport::Car", Vehicle
+
+    # STI requires inheritance: true option
+    result = diagram(:mermaid_style => :erdiagram, :inheritance => true).graph.join("\n")
+
+    # The specialization relationship should quote the namespaced entity
+    assert result.include?('"Transport::Car"'), "Should quote namespaced specialized entity"
+    # Verify the specialization relationship line also quotes it
+    assert result.match?(/Vehicle.*--.*"Transport::Car"/), "Specialization relationship should quote namespaced entity"
+  end
 end

data/test/unit/rake_task_test.rb

@@ -14,10 +14,6 @@ class RakeTaskTest < ActiveSupport::TestCase
     Rake.application.options.silent = true
   end
 
-  def teardown
-    FileUtils.rm "erd.dot" rescue nil
-  end
-
   define_method :create_app do
     Object::Quux = Module.new
     Object::Quux::Application = Class.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-erd
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Rolf Timmermans
@@ -178,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.13
 specification_version: 4
 summary: Entity-relationship diagram for your Rails models.
 test_files: