brick 1.0.25 → 1.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0dfa64d7a8a148b4c2ad990f5af1604d5855b80c6e95f39cd371a43a591b7f1
-  data.tar.gz: bc7644a08678136d91696a68e0ad670f4f04d41772f36ba1bd806ebe45f23b04
+  metadata.gz: ab7e6a8198638a0e6d3cde289db17d107e699fad2b4b5a200703cb1982d19569
+  data.tar.gz: 708360bb9463e45c8f7fece60dc762dc65b2b3893d8044ffce9ee87e33f63b80
 SHA512:
-  metadata.gz: a39a8adc0c72288db5bd08e2483cefb701db9c2122fe1b4012c19bef07c7d048fed7f6e051473a9b4b6c80e321e4a781a16543d40f3e569f23c31f420a5117b6
-  data.tar.gz: 3ddcc914e3143a02a4582d6f525417c3012ae4eafc9ae889d5935223f6173afb4fb5ff3a40dc6c9caf95dfbf7a3c5be8e7bc4890efb385867ef5fa6f3ccbfb9e
+  metadata.gz: 92229661eff9aac30ec7fad96603bc649a122131956e8632562e22d11c8bae67db0272ec5453ab2cc233bd11f7ab72222c3520f2acceecb83e35d4c54cbd8f4d
+  data.tar.gz: ddc169b2effaf58e60861d0153f191f6f1e2f11d459363a000da2c1f44c1583c8cd037f78269c238a84de58e04d7633c7a7ecbf046c08ef48fdaf5fb01de76a3

data/lib/brick/config.rb

@@ -122,6 +122,22 @@ 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 default_route_fallback
+      @mutex.synchronize { @default_route_fallback }
+    end
+
+    def default_route_fallback=(resource_name)
+      @mutex.synchronize { @default_route_fallback = resource_name }
+    end
+
     def skip_database_views
       @mutex.synchronize { @skip_database_views }
     end

data/lib/brick/extensions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Some future enhancement ideas:
+
 # Have markers on HM relationships to indicate "load this one every time" or "lazy load it" or "don't bother"
 # Others on BT to indicate "this is a lookup"
 
@@ -18,7 +20,7 @@
 # Sensitive stuff -- make a lock icon thing so people don't accidentally edit stuff
 
 # Static text that can go on pages - headings and footers and whatever
-# Eventually some indication about if it should be a paginated table / unpaginated / a list of just some fields / etc
+# Eventually some indication about if it should be a paginated table / unpaginated / a list of just some fields / columns shown in a different sequence / etc
 
 # Grid where each cell is one field and then when you mouse over then it shows a popup other table of detail inside
 
@@ -32,6 +34,9 @@
 
 # Currently quadrupling up routes
 
+# Modal pop-up things for editing large text / date ranges / hierarchies of data
+
+# For recognised self-references, have the show page display all related objects up to the parent (or the start of a circular reference)
 
 # ==========================================================
 # Dynamically create model or controller classes when needed
@@ -52,14 +57,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
@@ -70,6 +67,14 @@ module ActiveRecord
       false
     end
 
+    def self._brick_primary_key(relation = nil)
+      return instance_variable_get(:@_brick_primary_key) if instance_variable_defined?(:@_brick_primary_key)
+
+      pk = primary_key.is_a?(String) ? [primary_key] : primary_key || []
+      # Just return [] if we're missing any part of the primary key.  (PK is usually just "id")
+      @_brick_primary_key ||= pk.any? { |pk_part| !relation[:cols].key?(pk_part) } ? [] : pk
+    end
+
     # Used to show a little prettier name for an object
     def self.brick_get_dsl
       # If there's no DSL yet specified, just try to find the first usable column on this model
@@ -82,7 +87,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 +312,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) }
@@ -351,27 +357,24 @@ module ActiveRecord
             next if chains[k1].nil?
 
             tbl_name = field_tbl_names[v.first][k1] ||= shift_or_first(chains[k1])
-            # if (col_name = v1[1].last&.last) # col_name is weak when there are multiple, using sel_col.last instead
             field_tbl_name = nil
-            v1.map { |x|
-                    [translations[x[0..-2].map(&:to_s).join('.')], x.last]
-                  }.each_with_index do |sel_col, idx|
-              field_tbl_name ||= field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])
+            v1.map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
+              field_tbl_name = field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])
 
               selects << "#{"#{field_tbl_name}.#{sel_col.last}"} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
               v1[idx] << col_alias
             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|
@@ -391,7 +394,8 @@ module ActiveRecord
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
-                         hm.klass.primary_key || '*'
+                         pk = hm.klass.primary_key
+                         (pk.is_a?(Array) ? pk.first : pk) || '*'
                        end
         tbl_alias = "_br_#{hm.name}"
         pri_tbl = hm.active_record
@@ -454,8 +458,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 +533,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, nil) || ::Brick.existing_stis[model_name]&.constantize)
                                 base_model.table_name
                               else
                                 ActiveSupport::Inflector.pluralize(singular_table_name)
@@ -571,7 +574,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, nil) || ::Brick.existing_stis[model_name]&.constantize)
         is_sti = true
       else
         base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
@@ -591,16 +594,14 @@ class Object
           code << "  def self.is_view?; true; end\n"
         end
 
-        # Missing a primary key column?  (Usually "id")
-        ar_pks = primary_key.is_a?(String) ? [primary_key] : primary_key || []
         db_pks = relation[:cols]&.map(&:first)
-        has_pk = ar_pks.length.positive? && (db_pks & ar_pks).sort == ar_pks.sort
+        has_pk = _brick_primary_key(relation).length.positive? && (db_pks & _brick_primary_key).sort == _brick_primary_key.sort
         our_pks = relation[:pkey].values.first
         # No primary key, but is there anything UNIQUE?
         # (Sort so that if there are multiple UNIQUE constraints we'll pick one that uses the least number of columns.)
         our_pks = relation[:ukeys].values.sort { |a, b| a.length <=> b.length }.first unless our_pks&.present?
         if has_pk
-          code << "  # Primary key: #{ar_pks.join(', ')}\n" unless ar_pks == ['id']
+          code << "  # Primary key: #{_brick_primary_key.join(', ')}\n" unless _brick_primary_key == ['id']
         elsif our_pks&.present?
           if our_pks.length > 1 && respond_to?(:'primary_keys=') # Using the composite_primary_keys gem?
             new_model_class.primary_keys = our_pks
@@ -620,10 +621,13 @@ class Object
             # The key in each hash entry (fk.first) is the constraint name
             inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
             if (invs = assoc[:inverse_table]).is_a?(Array)
-              invs.each { |inv| build_bt_or_hm(relations, model_name, relation, hmts, assoc, inverse_assoc_name, inv, code) }
-            else
-              build_bt_or_hm(relations, model_name, relation, hmts, assoc, inverse_assoc_name, invs, code)
+              if assoc[:is_bt]
+                invs = invs.first # Just do the first one of what would be multiple identical polymorphic belongs_to
+              else
+                invs.each { |inv| build_bt_or_hm(relations, model_name, relation, hmts, assoc, inverse_assoc_name, inv, code) }
+              end
             end
+            build_bt_or_hm(relations, model_name, relation, hmts, assoc, inverse_assoc_name, invs, code) unless invs.is_a?(Array)
             hmts
           end
           hmts.each do |hmt_fk, fks|
@@ -650,7 +654,7 @@ class Object
           # # Not NULLables
           # # %%% For the minute we've had to pull this out because it's been troublesome implementing the NotNull validator
           # relation[:cols].each do |col, datatype|
-          #   if (datatype[3] && ar_pks.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
+          #   if (datatype[3] && _brick_primary_key.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
           #      ::Brick.config.not_nullables.include?("#{matching}.#{col}")
           #     code << "  validates :#{col}, not_null: true\n"
           #     self.send(:validates, col.to_sym, { not_null: true })
@@ -698,9 +702,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
@@ -748,13 +751,14 @@ class Object
     def build_controller(class_name, plural_class_name, model, relations)
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
+      pk = model._brick_primary_key(relations[table_name])
 
       code = +"class #{class_name} < ApplicationController\n"
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
         Object.const_set(class_name.to_sym, new_controller_class)
 
         code << "  def index\n"
-        code << "    @#{table_name} = #{model.name}#{model.primary_key ? ".order(#{model.primary_key.inspect})" : '.all'}\n"
+        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
         code << "    @#{table_name}.brick_select(params)\n"
         code << "  end\n"
         self.protect_from_forgery unless: -> { self.request.format.js? }
@@ -772,7 +776,8 @@ class Object
             return
           end
 
-          ar_relation = model.primary_key ? model.order("#{model.table_name}.#{model.primary_key}") : model.all
+          order = pk.each_with_object([]) { |pk_part, s| s << "#{model.table_name}.#{pk_part}" }
+          ar_relation = order.present? ? model.order("#{order.join(', ')}") : model.all
           @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
@@ -787,11 +792,15 @@ class Object
 
         if model.primary_key
           code << "  def show\n"
-          code << (find_by_id = "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n")
+          code << (find_by_id = "    id = params[:id]&.split(/[\\/,_]/)
+    id = id.first if id.is_a?(Array) && id.length == 1
+    @#{singular_table_name} = #{model.name}.find(id)\n")
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
-            instance_variable_set("@#{singular_table_name}".to_sym, model.find(params[:id].split(',')))
+            id = params[:id]&.split(/[\/,_]/)
+            id = id.first if id.is_a?(Array) && id.length == 1
+            instance_variable_set("@#{singular_table_name}".to_sym, model.find(id))
           end
         end
 
@@ -800,6 +809,10 @@ class Object
           code << "  # (Define :new, :create)\n"
 
           if model.primary_key
+            if (schema = ::Brick.config.schema_to_analyse) && ::Brick.db_schemas&.include?(schema)
+              ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
+            end
+
             is_need_params = true
             # code << "  # (Define :edit, and :destroy)\n"
             code << "  def update\n"
@@ -874,12 +887,12 @@ module ActiveRecord::ConnectionHandling
   def _brick_reflect_tables
     if (relations = ::Brick.relations).empty?
     # Only for Postgres?  (Doesn't work in sqlite3)
-    # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
+    # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
     schema_sql = 'SELECT NULL AS table_schema;'
     case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
-        schema = 'public'
+        schema = 'public' # Too early at this point to be able to pick up:  Brick.config.schema_to_analyse
         schema_sql = 'SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;'
       when 'Mysql2'
         schema = ActiveRecord::Base.connection.current_database
@@ -923,7 +936,7 @@ module ActiveRecord::ConnectionHandling
       measures = []
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
-        ActiveRecord::Base.connection.execute(sql).each do |r|
+        ActiveRecord::Base.execute_sql(sql).each do |r|
           # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
           relation = relations[(relation_name = r['relation_name'])]
           relation[:isView] = true if r['table_type'] == 'VIEW'
@@ -942,7 +955,7 @@ module ActiveRecord::ConnectionHandling
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
         end
       else # MySQL2 acts a little differently, bringing back an array for each row
-        ActiveRecord::Base.connection.execute(sql).each do |r|
+        ActiveRecord::Base.execute_sql(sql).each do |r|
           # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
           relation = relations[(relation_name = r[0])] # here relation represents a table or view from the database
           relation[:isView] = true if r[1] == 'VIEW' # table_type
@@ -1008,11 +1021,11 @@ module ActiveRecord::ConnectionHandling
       else
       end
       if sql
-        ::Brick.db_schemas = ActiveRecord::Base.connection.execute(schema_sql)
+        ::Brick.db_schemas = ActiveRecord::Base.execute_sql(schema_sql)
         ::Brick.db_schemas = ::Brick.db_schemas.to_a unless ::Brick.db_schemas.is_a?(Array)
         ::Brick.db_schemas.map! { |row| row['table_schema'] } unless ::Brick.db_schemas.empty? || ::Brick.db_schemas.first.is_a?(String)
         ::Brick.db_schemas -= ['information_schema', 'pg_catalog']
-        ActiveRecord::Base.connection.execute(sql).each do |fk|
+        ActiveRecord::Base.execute_sql(sql).each do |fk|
           fk = fk.values unless fk.is_a?(Array)
           ::Brick._add_bt_and_hm(fk, relations)
         end
@@ -1064,12 +1077,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 +1111,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 +1134,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_hm[:fk].is_a?(String)
+          assoc_hm[:fk] = [assoc_hm[:fk], fk[1]] unless fk[1] == assoc_hm[:fk]
+        elsif assoc_hm[:fk].exclude?(fk[1])
+          assoc_hm[: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

@@ -71,7 +71,8 @@ module Brick
               keys = if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
                        fk_name.zip(pk.map { |pk_part| "#{obj_name}.#{pk_part}" })
                      else
-                       [[fk_name, "#{obj_name}.#{pk}"]]
+                       pk = pk.each_with_object([]) { |pk_part, s| s << "#{obj_name}.#{pk_part}" }
+                       [[fk_name, "#{pk.length == 1 ? pk.first : pk.inspect}"]]
                      end
               keys << [hm_assoc.inverse_of.foreign_type, "#{hm_assoc.active_record.name}"] if hm_assoc.options.key?(:as)
               keys.map { |x| "#{x.first}: #{x.last}"}.join(', ')
@@ -82,7 +83,7 @@ module Brick
               return  _brick_find_template(*args, **options) unless @_brick_model
 
               model_name = @_brick_model.name
-              pk = @_brick_model.primary_key
+              pk = @_brick_model._brick_primary_key(::Brick.relations[model_name])
               obj_name = model_name.underscore
               table_name = model_name.pluralize.underscore
               template_link = nil
@@ -112,7 +113,7 @@ module Brick
 "<%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>\n"
                                  end
                 elsif args.first == 'show'
-                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}&.first&", pk)} }) %>\n"
+                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
                 end
                 s << hm_stuff
               end
@@ -210,16 +211,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
@@ -280,7 +284,7 @@ function changeout(href, param, value) {
               inline = case args.first
                        when 'index'
                          obj_pk = if pk&.is_a?(Array) # Composite primary key?
-                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]"
+                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]" unless pk.empty?
                                   elsif pk
                                     "#{obj_name}.#{pk}"
                                   end
@@ -382,9 +386,9 @@ function changeout(href, param, value) {
 
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
 <table id=\"#{table_name}\">
-  <thead><tr>#{'<th></th>' if pk}
+  <thead><tr>#{'<th></th>' if pk.present?}
   <% @#{table_name}.columns.map(&:name).each do |col| %>
-    <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
+    <% next if #{pk.inspect}.include?(col) || ::Brick.config.metadata_columns.include?(col) || poly_cols.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
          BT <%
@@ -405,22 +409,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 #{obj_pk.inspect}.include?(k) || ::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 %>
@@ -441,7 +445,7 @@ function changeout(href, param, value) {
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
-<h1>#{model_name}: <%= (obj = @#{obj_name}&.first)&.brick_descrip || controller_name %></h1>
+<h1>#{model_name}: <%= (obj = @#{obj_name})&.brick_descrip || controller_name %></h1>
 <%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
 <% if obj %>
   <%= # path_options = [obj.#{pk}]
@@ -450,32 +454,42 @@ function changeout(href, param, value) {
     form_for(obj.becomes(#{model_name})) do |f| %>
   <table>
   <% has_fields = false
-    @#{obj_name}.first.attributes.each do |k, val| %>
+    @#{obj_name}.attributes.each do |k, val| %>
     <tr>
     <%# %%% Accommodate composite keys %>
-    <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+    <% next if #{pk}.include?(k) || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
     <% has_fields = true
       if (bt = bts[k])
         # 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
-          poly_class_name = @#{obj_name}.first.send(\"#\{bt.first\}_type\")
-          bt_pair = pairs.find { |pair| pair.first.name == poly_class_name }
+        if bt[2] # Polymorphic?
+          poly_class_name = orig_poly_name = @#{obj_name}.send(\"#\{bt.first\}_type\")
+          bt_pair = nil
+          loop do
+            bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
+            # Acxommodate any valid STI by going up the chain of inheritance
+            break unless bt_pair.nil? && poly_class_name = ::Brick.existing_stis[poly_class_name]
+          end
+          puts \"*** Might be missing an STI class called #\{orig_poly_name\} whose base class should have this:
+***   has_many :#{table_name}, as: :#\{bt.first\}
+*** Can probably auto-configure everything using these lines in an initialiser:
+***   Brick.sti_namespace_prefixes = { '::#\{orig_poly_name\}' => 'SomeParentModel' }
+***   Brick.polymorphics = { '#{table_name}.#\{bt.first\}' => ['SomeParentModel'] }\" if bt_pair.nil?
           # descrips = @_brick_bt_descrip[bt.first][bt_class]
-          poly_id = @#{obj_name}.first.send(\"#\{bt.first\}_id\")
+          poly_id = @#{obj_name}.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)] }
         else # No polymorphism, so just get the first one
           bt_pair = bt[1].first
         end
-        bt_class = bt_pair.first
-        if bt.length < 3
+        bt_class = bt_pair&.first
+        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)] }
+          bt_class&.order(obj_pk = bt_class.primary_key)&.each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
         end %>
-        BT <%= bt_class.bt_link(bt.first) %>
+        BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
     <% else %>
       <%= k %>
     <% end %>
@@ -484,8 +498,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? %>
@@ -517,16 +531,17 @@ function changeout(href, param, value) {
 
   #{hms_headers.each_with_object(+'') do |hm, s|
     if (pk = hm.first.klass.primary_key)
-      s << "<table id=\"#{hm_name = hm.first.name.to_s}\">
+      hm_singular_name = (hm_name = hm.first.name.to_s).singularize.underscore
+      obj_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "#{hm_singular_name}.#{pk_part}" }.join(', ')
+      s << "<table id=\"#{hm_name}\">
         <tr><th>#{hm[3]}</th></tr>
-        <% collection = @#{obj_name}.first.#{hm_name}
+        <% collection = @#{obj_name}.#{hm_name}
         collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
         if collection.empty? %>
           <tr><td>(none)</td></tr>
         <% else %>
-          <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
-            <%# %%% accommodate composite primary key %>
-            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
+          <% collection.uniq.each do |#{hm_singular_name}| %>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path([#{obj_pk}])) %></td></tr>
           <% end %>
         <% end %>
       </table>"
@@ -538,7 +553,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/join_array.rb

@@ -213,7 +213,7 @@ module Brick
           puts "X3"
           super(key, ::Brick::JoinArray.new.replace([current, value]))
         when ::Brick::JoinArray # Concatenate new stuff onto any existing JoinArray
-          current.set_matching(value, nil)
+          current.set_matching(value, nil) if value
         when ::Brick::JoinHash # Graduate an existing hash into being in an array if things are dissimilar
           super(key, ::Brick::JoinArray.new.replace([current, value]))
           value

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 25
+    TINY = 28
 
     # 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,17 @@ 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
+
+    def default_route_fallback=(resource_name)
+      Brick.config.default_route_fallback = resource_name
+    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 +305,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}' => 'SomeParentModel'" }.join(',')
+            puts "  }
+(Just trade out SomeParentModel with some more appropriate one.)"
+          end
         end
         @_additional_references_loaded = true
       end
@@ -352,6 +385,9 @@ module Brick
     def finalize!
       existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
       ::Rails.application.routes.append do
+        unless ::Brick.config.default_route_fallback.blank? || ::Rails.application.routes.named_routes.send(:routes)[:root]
+          send(:root, "#{::Brick.config.default_route_fallback}#index")
+        end
         # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
         # If auto-controllers and auto-models are both enabled then this makes sense:
         ::Brick.relations.each do |k, v|
@@ -415,7 +451,7 @@ ActiveSupport.on_load(:active_record) do
             relation = clone # spawn
             relation.select_values = column_names
             result = if klass.connection.class.name.end_with?('::PostgreSQLAdapter')
-                       rslt = klass.connection.execute(relation.arel.to_sql)
+                       rslt = klass.execute_sql(relation.arel.to_sql)
                        rslt.type_map =
                          @type_map ||= proc do
                            # This aliasing avoids the warning:

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.map { |poss_poly| "#{poss_poly} => nil"}).length
+      when 0
+" like this:
+# Brick.polymorphics = {
+#                        'comments.commentable' => nil,
+#                        'images.imageable' => nil
+#                      }"
+      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.28
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-21 00:00:00.000000000 Z
+date: 2022-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord