rails-erd 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96a5321997e7b69697914d2555515de577676734e66f60cf0b76ff6c6f307846
-  data.tar.gz: 973f6409aeb4fcd221659e4c9dabadd4a32a047218ea056b4b24b9c71476454c
+  metadata.gz: 4d47dd705b783be29e06d39d8bea92d6c5ac8019fba658e0279287b2197938d3
+  data.tar.gz: 1417646a7d2731ad2964e9cbac400cb3b2325f765ba1db610b44f28ffe03f699
 SHA512:
-  metadata.gz: c5b98489174be741cf8056040f3a6eadd2c5ab673dfb9463b2db0b4fe7e9209a742765464b02c842b859c700231285cae40cfbcbe4eca3bed24d3cf1a191b453
-  data.tar.gz: 3793cbe2da98c90a4e379864e7dd5e3d4072248ff8245dfa5dfc75d0957e9c9e1f6aab4140ec54af00010312c53791e513e3898b41e2669c365802151497d9aa
+  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.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.1"
+  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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-erd
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  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: