brick 1.0.25 → 1.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0dfa64d7a8a148b4c2ad990f5af1604d5855b80c6e95f39cd371a43a591b7f1
-  data.tar.gz: bc7644a08678136d91696a68e0ad670f4f04d41772f36ba1bd806ebe45f23b04
+  metadata.gz: 922a55ec392e2ea9cef11c7297e4c2e4883e918130a23e49102b5a7e2442140e
+  data.tar.gz: 7cda213ec2e7cdccae096ef4ad8091a53a91359a1e6fabeb753cc2b579ac5c16
 SHA512:
-  metadata.gz: a39a8adc0c72288db5bd08e2483cefb701db9c2122fe1b4012c19bef07c7d048fed7f6e051473a9b4b6c80e321e4a781a16543d40f3e569f23c31f420a5117b6
-  data.tar.gz: 3ddcc914e3143a02a4582d6f525417c3012ae4eafc9ae889d5935223f6173afb4fb5ff3a40dc6c9caf95dfbf7a3c5be8e7bc4890efb385867ef5fa6f3ccbfb9e
+  metadata.gz: 7b817257f9c2aedd47bc2471b12e13edc8b370b71920258755f0f9a7594060e065d022e8d4b2b360cdc41f2a60def02cfc406889d526d80088670bd64acd58be
+  data.tar.gz: 1ea923301103dcc53853940770861ab5c2635f1280026e0740287274c0e9bb7d566ddcf96db0d3858467b788bc9ee4b73e7bcfc61145be1bbb43775cfb859b80

data/lib/brick/config.rb

@@ -122,6 +122,14 @@ module Brick
       @mutex.synchronize { @sti_namespace_prefixes = prefixes }
     end
 
+    def schema_to_analyse
+      @mutex.synchronize { @schema_to_analyse }
+    end
+
+    def schema_to_analyse=(schema)
+      @mutex.synchronize { @schema_to_analyse = schema }
+    end
+
     def skip_database_views
       @mutex.synchronize { @skip_database_views }
     end

data/lib/brick/extensions.rb

@@ -52,14 +52,6 @@ module Arel
   end
 end
 
-# module ActiveModel
-#   class NotNullValidator < EachValidator
-#     def validate_each(record, attribute, value)
-#       record.errors[attribute] << "must not be null" if value.nil?
-#     end
-#   end
-# end
-
 module ActiveRecord
   class Base
     def self._assoc_names
@@ -82,7 +74,6 @@ module ActiveRecord
       dsl
     end
 
-    # Pass in true for build_array, or just pass in a JoinArray
     def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false)
       build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
       build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
@@ -308,6 +299,8 @@ module ActiveRecord
       if is_add_bts || is_add_hms
         bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
         bts.each do |_k, bt|
+          next if bt[2] # Polymorphic?
+
           # join_array will receive this relation name when calling #brick_parse_dsl
           bt_descrip[bt.first] = if bt[1].is_a?(Array)
                                    bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
@@ -363,15 +356,16 @@ module ActiveRecord
             end
             # end
 
-            if (id_col = k1.primary_key) && !id_for_tables.key?(v.first) # was tbl_name
+            unless id_for_tables.key?(v.first)
               # Accommodate composite primary key by allowing id_col to come in as an array
-              (id_col.is_a?(Array) ? id_col : [id_col]).each do |id_part|
-                selects << "#{"#{tbl_name}.#{id_part}"} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
-                id_for_tables[v.first] << id_alias
+              ((id_col = k1.primary_key).is_a?(Array) ? id_col : [id_col]).each do |id_part|
+                id_for_tables[v.first] << if id_part
+                                            selects << "#{"#{tbl_name}.#{id_part}"} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+                                            id_alias
+                                          end
               end
-              v1 << id_for_tables[v.first]
+              v1 << id_for_tables[v.first].compact
             end
-
           end
         end
         join_array.each do |assoc_name|
@@ -454,8 +448,7 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associ
               this_module.const_get(class_name)
             else
               # Build STI subclass and place it into the namespace module
-              # %%% Does this ever get used???
-              puts [this_module.const_set(class_name, klass = Class.new(self)).name, class_name].inspect
+              this_module.const_set(class_name, klass = Class.new(self))
               klass
             end
           end
@@ -530,7 +523,7 @@ class Object
                  singular_table_name = ActiveSupport::Inflector.underscore(model_name)
  
                  # Adjust for STI if we know of a base model for the requested model name
-                 table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+                 table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, ::Brick.existing_stis[model_name]&.constantize))
                                 base_model.table_name
                               else
                                 ActiveSupport::Inflector.pluralize(singular_table_name)
@@ -571,7 +564,7 @@ class Object
         return
       end
 
-      if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+      if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, ::Brick.existing_stis[model_name]&.constantize))
         is_sti = true
       else
         base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
@@ -698,9 +691,8 @@ class Object
                 # need_class_name = ActiveSupport::Inflector.singularize(assoc_name) == ActiveSupport::Inflector.singularize(table_name.underscore)
                 # Are there multiple foreign keys out to the same table?
                 assoc_name, need_class_name = _brick_get_hm_assoc_name(relation, assoc)
-                # binding.pry if assoc.key?(:polymorphic)
                 if assoc.key?(:polymorphic)
-                  options[:as] = assoc[:fk].to_sym if assoc.key?(:polymorphic)
+                  options[:as] = assoc[:fk].to_sym
                 else
                   need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
                 end
@@ -1064,12 +1056,8 @@ module Brick
       bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
       # %%% Do we miss out on has_many :through or even HM based on constantizing this model early?
       # Maybe it's already gotten this info because we got as far as to say there was a unique class
-      # if is_polymorphic
-      #   primary_table = fk[]
-      # else
-        primary_table = (is_class = fk[2].is_a?(Hash) && fk[2].key?(:class)) ? (primary_class = fk[2][:class].constantize).table_name : fk[2]
-        hms = (relation = relations.fetch(primary_table, nil))&.fetch(:fks) { relation[:fks] = {} } unless is_class
-      # end
+      primary_table = (is_class = fk[2].is_a?(Hash) && fk[2].key?(:class)) ? (primary_class = fk[2][:class].constantize).table_name : fk[2]
+      hms = (relation = relations.fetch(primary_table, nil))&.fetch(:fks) { relation[:fks] = {} } unless is_class
 
       unless (cnstr_name = fk[3])
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
@@ -1102,8 +1090,12 @@ module Brick
         if is_polymorphic
           # Assuming same fk (don't yet support composite keys for polymorphics)
           assoc_bt[:inverse_table] << fk[2]
-        else # Expect we've got a composite key going
-          assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[1]] : assoc_bt[:fk].concat(fk[1])
+        else # Expect we could have a composite key going
+          if assoc_bt[:fk].is_a?(String)
+            assoc_bt[:fk] = [assoc_bt[:fk], fk[1]] unless fk[1] == assoc_bt[:fk]
+          elsif assoc_bt[:fk].exclude?(fk[1])
+            assoc_bt[:fk] << fk[1]
+          end
           assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
         end
       else
@@ -1121,7 +1113,11 @@ module Brick
       return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
 
       if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
-        assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
+        if assoc_bt[:fk].is_a?(String)
+          assoc_bt[:fk] = [assoc_bt[:fk], fk[1]] unless fk[1] == assoc_bt[:fk]
+        elsif assoc_bt[:fk].exclude?(fk[1])
+          assoc_bt[:fk] << fk[1]
+        end
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
         assoc_hm[:inverse] = assoc_bt
       else

data/lib/brick/frameworks/rails/engine.rb

@@ -210,16 +210,19 @@ def hide_bcrypt(val)
 end %>"
 
               if ['index', 'show', 'update'].include?(args.first)
+                poly_cols = []
                 css << "<% bts = { #{
                   bts.each_with_object([]) do |v, s|
-                    foreign_models = if v.last[1].is_a?(Array)
+                    foreign_models = if v.last[2] # Polymorphic?
+                                       poly_cols << @_brick_model.reflect_on_association(v[1].first).foreign_type
                                        v.last[1].each_with_object([]) { |x, s| s << "[#{x.name}, #{x.primary_key.inspect}]" }.join(', ')
                                      else
                                        "[#{v.last[1].name}, #{v.last[1].primary_key.inspect}]"
                                      end
-                    s << "#{v.first.inspect} => [#{v.last.first.inspect}, [#{foreign_models}]]"
+                    s << "#{v.first.inspect} => [#{v.last.first.inspect}, [#{foreign_models}], #{v.last[2].inspect}]"
                   end.join(', ')
-                } } %>"
+                } }
+                poly_cols = #{poly_cols.inspect} %>"
               end
 
               # %%% When doing schema select, if there's an ID then remove it, or if we're on a new page go to index
@@ -384,7 +387,7 @@ function changeout(href, param, value) {
 <table id=\"#{table_name}\">
   <thead><tr>#{'<th></th>' if pk}
   <% @#{table_name}.columns.map(&:name).each do |col| %>
-    <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
+    <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) || poly_cols.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
          BT <%
@@ -405,22 +408,22 @@ function changeout(href, param, value) {
   <tr>#{"
     <td><%= link_to '⇛', #{obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% #{obj_name}.attributes.each do |k, val| %>
-      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && (k.length == 63 || k.end_with?('_ct'))) %>
+      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) || poly_cols.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && (k.length == 63 || k.end_with?('_ct'))) %>
       <td>
       <% if (bt = bts[k]) %>
         <%# binding.pry # Postgres column names are limited to 63 characters %>
-        <% if (pairs = bt[1].length > 1)
+        <% if bt[2] # Polymorphic?
              bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
-             # descrips = @_brick_bt_descrip[bt.first][bt_class]
+             base_class = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class.name.underscore
              poly_id = #{obj_name}.send(\"#\{bt.first\}_id\")
              %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\",
-                           send(\"#\{bt_class.underscore\}_path\".to_sym, poly_id)) if poly_id %><%
-           else # We should do something other than [0..-2] for when there is no primary key (or maybe have an empty final array there in that case?)
-              bt_txt = (bt_class = bt[1].first.first).brick_descrip(
-                #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |z| #{obj_name}.send(z.last[0..62]) }, (bt_id_col = descrips.last)
-              )
-              bt_id = #{obj_name}.send(*bt_id_col) if bt_id_col&.present? %>
-          <%= bt_id ? link_to(bt_txt, send(\"#\{bt_class.name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
+                           send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
+           else
+             bt_txt = (bt_class = bt[1].first.first).brick_descrip(
+               #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |z| #{obj_name}.send(z.last[0..62]) }, (bt_id_col = descrips.last)
+             )
+             bt_id = #{obj_name}.send(*bt_id_col) if bt_id_col&.present? %>
+          <%= bt_id ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
           <%#= Previously was:  bt_obj = bt[1].first.first.find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt[1].first.first.name.underscore\}_path\".to_sym, bt_obj.send(bt[1].first.first.primary_key.to_sym))) if bt_obj %>
         <% end %>
       <% else %>
@@ -460,9 +463,9 @@ function changeout(href, param, value) {
         # Add a final member in this array with descriptive options to be used in <select> drop-downs
         bt_name = bt[1].map { |x| x.first.name }.join('/')
         # %%% Only do this if the user has permissions to edit this bt field
-        if (pairs = bt[1]).length > 1
+        if bt[2] # Polymorphic?
           poly_class_name = @#{obj_name}.first.send(\"#\{bt.first\}_type\")
-          bt_pair = pairs.find { |pair| pair.first.name == poly_class_name }
+          bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
           # descrips = @_brick_bt_descrip[bt.first][bt_class]
           poly_id = @#{obj_name}.first.send(\"#\{bt.first\}_id\")
           # bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
@@ -470,7 +473,7 @@ function changeout(href, param, value) {
           bt_pair = bt[1].first
         end
         bt_class = bt_pair.first
-        if bt.length < 3
+        if bt.length < 4
           bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
           # %%% Accommodate composite keys for obj.pk at the end here
           bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
@@ -484,8 +487,8 @@ function changeout(href, param, value) {
     <% if bt
       html_options = { prompt: \"Select #\{bt_name\}\" }
       html_options[:class] = 'dimmed' unless val %>
-      <%= f.select k.to_sym, bt[2], { value: val || '^^^brick_NULL^^^' }, html_options %>
-      <%= bt_obj = bt_class.find_by(bt_pair[1] => val); link_to('⇛', send(\"#\{bt_class.name.underscore\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+      <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
+      <%= bt_obj = bt_class.find_by(bt_pair[1] => val); link_to('⇛', send(\"#\{bt_class.base_class.name.underscore\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
@@ -538,7 +541,6 @@ function changeout(href, param, value) {
 #{script}"
 
                        end
-              puts inline
               # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
               keys = options.has_key?(:locals) ? options[:locals].keys : []
               handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 25
+    TINY = 26
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/brick.rb

@@ -85,12 +85,16 @@ module Brick
     @sti_models ||= {}
   end
 
+  def self.existing_stis
+    @existing_stis ||= Brick.config.sti_namespace_prefixes.each_with_object({}) { |snp, s| s[snp.first[2..-1]] = snp.last unless snp.first.end_with?('::') }
+  end
+
   class << self
     attr_accessor :db_schemas
 
     def set_db_schema(params)
       schema = params['_brick_schema'] || 'public'
-      ActiveRecord::Base.connection.execute("SET SEARCH_PATH='#{schema}';") if schema && ::Brick.db_schemas&.include?(schema)
+      ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema) if schema && ::Brick.db_schemas&.include?(schema)
     end
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
@@ -103,14 +107,14 @@ module Brick
 
     def get_bts_and_hms(model)
       bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
-        next if (!const_defined?(a.name.to_s.singularize.camelize) && ::Brick.config.exclude_tables.include?(a.plural_name))
+        next if !const_defined?(a.name.to_s.singularize.camelize) && ::Brick.config.exclude_tables.include?(a.plural_name)
 
         case a.macro
         when :belongs_to
           s.first[a.foreign_key] = if a.polymorphic?
                                      primary_tables = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }&.last&.fetch(:inverse_table, [])
                                      models = primary_tables&.map { |table| table.singularize.camelize.constantize }
-                                     [a.name, models]
+                                     [a.name, models, true]
                                    else
                                      [a.name, a.klass]
                                    end
@@ -264,6 +268,7 @@ module Brick
 
     # Polymorphic associations
     def polymorphics=(polys)
+      polys = polys.each_with_object({}) { |poly, s| s[poly] = nil } if polys.is_a?(Array)
       Brick.config.polymorphics = polys || {}
     end
 
@@ -279,6 +284,13 @@ module Brick
       Brick.config.sti_namespace_prefixes = snp
     end
 
+    # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes
+    # for polymorphics in which it wasn't originally specified.
+    # @api public
+    def schema_to_analyse=(schema)
+      Brick.config.schema_to_analyse = schema
+    end
+
     # Load additional references (virtual foreign keys)
     # This is attempted early if a brick initialiser file is found, and then again as a failsafe at the end of our engine's initialisation
     # %%% Maybe look for differences the second time 'round and just add new stuff instead of entirely deferring
@@ -289,13 +301,30 @@ module Brick
       if (ars = ::Brick.config.additional_references) || ::Brick.config.polymorphics
         ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2], relations) } if ars
         if (polys = ::Brick.config.polymorphics)
+          if (schema = ::Brick.config.schema_to_analyse) && ::Brick.db_schemas&.include?(schema)
+            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
+          end
+          missing_stis = {}
           polys.each do |k, v|
             table_name, poly = k.split('.')
             v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").map { |result| result['typ'] }
             v.each do |type|
-              ::Brick._add_bt_and_hm([table_name, poly, type.underscore.pluralize, "(brick) #{table_name}_#{poly}"], relations, true)
+              if relations.key?(primary_table = type.underscore.pluralize)
+                ::Brick._add_bt_and_hm([table_name, poly, primary_table, "(brick) #{table_name}_#{poly}"], relations, true)
+              else
+                missing_stis[primary_table] = type unless ::Brick.existing_stis.key?(type)
+              end
             end
           end
+          unless missing_stis.empty?
+            print "
+You might be missing an STI namespace prefix entry for these tables:  #{missing_stis.keys.join(', ')}.
+In config/initializers/brick.rb appropriate entries would look something like:
+  Brick.sti_namespace_prefixes = {"
+            puts missing_stis.map { |_k, missing_sti| "\n    '::#{missing_sti}' => 'YourParentModel'" }.join(',')
+            puts "  }
+(Just trade out YourParentModel with some more appropriate one.)"
+          end
         end
         @_additional_references_loaded = true
       end

data/lib/generators/brick/install_generator.rb

@@ -19,11 +19,31 @@ module Brick
 
     def create_initializer_file
       unless File.exist?(filename = 'config/initializers/brick.rb')
-        # See if we can make suggestions for additional_references
-        resembles_fks = []
-        possible_additional_references = (relations = ::Brick.relations).each_with_object([]) do |v, s|
-          v.last[:cols].each do |col, _type|
+        # See if we can make suggestions for additional_references and polymorphic associations
+        resembles_fks = Hash.new { |h, k| h[k] = [] }
+        possible_polymorphics = {}
+        possible_additional_references = (relations = ::Brick.relations).each_with_object(Hash.new { |h, k| h[k] = [] }) do |v, s|
+          model_filename = "app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb"
+          v.last[:cols].each do |col, type|
             col_down = col.downcase
+
+            if (is_possible_poly = ['character varying', 'text'].include?(type.first))
+              if col_down.end_with?('_type') &&
+                poly_type_cut_length = -6
+                col_down = col_down[0..-6]
+              elsif col_down.end_with?('type')
+                poly_type_cut_length = -5
+                col_down = col_down[0..-5]
+              else
+                is_possible_poly = false
+              end
+              is_possible_poly = false if col_down.length < 6 # Was it simply called "type" or something else really short?
+              if is_possible_poly && !File.exist?(model_filename) # Make sure a model file isn't present
+                possible_polymorphics["#{v.first}.#{col_down}"] = "'#{v.first}.#{col[0..poly_type_cut_length]}'"
+                next
+              end
+            end
+
             is_possible = true
             if col_down.end_with?('_id')
               col_down = col_down[0..-4]
@@ -40,30 +60,48 @@ module Brick
             if col_down.start_with?('fk_')
               is_possible = true
               col_down = col_down[3..-1]
+            elsif col_down.start_with?('fk')
+              is_possible = true
+              col_down = col_down[2..-1]
             end
             # This possible key not really a primary key and not yet used as a foreign key?
             if is_possible && !(relation = relations.fetch(v.first, {}))[:pkey].first&.last&.include?(col) &&
                !relations.fetch(v.first, {})[:fks]&.any? { |_k, v| v[:is_bt] && v[:fk] == col }
-              if (relations.fetch(f_table = col_down, nil) ||
-                 relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
-                 # Looks pretty promising ... just make sure a model file isn't present
-                 !File.exist?("app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb")
-                s << "['#{v.first}', '#{col}', '#{f_table}']"
-              else
-                resembles_fks << "#{v.first}.#{col}"
+              # Starting to look promising ... make sure a model file isn't present
+              if !File.exist?(model_filename)
+                if (relations.fetch(f_table = col_down, nil) ||
+                  relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
+                  s["#{v.first}.#{col_down}"] << "['#{v.first}', '#{col}', '#{f_table}']"
+                else
+                  resembles_fks["#{v.first}.#{col_down}"] << "#{v.first}.#{col}"
+                end
               end
             end
           end
-          s
         end
 
-        bar = case possible_additional_references.length
+        possible_polymorphics.each_key do |k|
+          # Also matching one of the FK suggestions means it could be polymorphic,
+          # so delete any suggestions for a FK of the same name and only recommend
+          # the polymorphic association.
+          if resembles_fks.key?(k)
+            resembles_fks.delete(k)
+          elsif possible_additional_references.key?(k)
+            possible_additional_references.delete(k)
+          else
+            # While this one has a type, it's missing a corresponding ID column so it isn't polymorphic
+            possible_polymorphics.delete(k)
+          end
+        end
+        resembles_fks = resembles_fks.values.flatten
+
+        bar = case (possible_additional_references = possible_additional_references.values.flatten).length
               when 0
 +"# Brick.additional_references = [['orders', 'customer_id', 'customer'],
 #                                ['customer', 'region_id', 'regions']]"
               when 1
 +"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
-# Brick.additional_references = [[#{possible_additional_references.first}]"
+# Brick.additional_references = [#{possible_additional_references.first}]"
               else
 +"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
 # Brick.additional_references = [
@@ -75,6 +113,26 @@ module Brick
 # #   #{resembles_fks.join(', ')}"
       end
 
+      poly = case (possible_polymorphics = possible_polymorphics.values.flatten).length
+      when 0
+" like this:
+# Brick.polymorphics = [
+#                        'comments.commentable',
+#                        'images.imageable'
+#                      ]"
+      when 1
+".
+# # Here is a possible polymorphic association that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+# Brick.polymorphics = [#{possible_additional_references.first}]"
+
+      else
+".
+# # Here are possible polymorphic associations that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+# Brick.polymorphics = [
+#   #{possible_polymorphics.join(",\n#   ")}
+# ]"
+      end
+
       create_file(filename, "# frozen_string_literal: true
 
 # # Settings for the Brick gem
@@ -119,7 +177,7 @@ module Brick
 # # Skip showing counts for these specific has_many associations when building auto-generated #index views.
 # # When there are related tables with a significant number of records, this can lessen the load on the database
 # # considerably, sometimes fixing what might appear to be an index page that just \"hangs\" for no apparent reason.
-Brick.skip_index_hms = ['User.litany_of_woes']
+# Brick.skip_index_hms = ['User.litany_of_woes']
 
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
 # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
@@ -157,9 +215,11 @@ Brick.skip_index_hms = ['User.litany_of_woes']
 # Brick.sti_namespace_prefixes = { '::Animals::' => 'Animal',
 #                                  '::Snake' => 'Reptile' }
 
-# # Polymorphic associations must be explicitly specified, which is as easy as providing a model name and polymorphic
-# # association name like this:
-# Brick.polymorphics = ['Comment.commentable', 'Image.imageable']
+# # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes in the case that
+# # it wasn't originally specified.
+# Brick.schema_to_analyse = 'engineering'
+
+# # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 
 # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
 # # route to go to the :index action for what would be a controller for that table.  You can specify any controller

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.25
+  version: 1.0.26
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-21 00:00:00.000000000 Z
+date: 2022-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord