brick 1.0.22 → 1.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82ebef3561b9cd7b8abcbbd8a30b7687485543ddf1a0900a9935dfb99299f13f
-  data.tar.gz: ba071d53409fd8d4833693907364c745585aeb0bb18e885fcf7cbf1bd23b9940
+  metadata.gz: b0dfa64d7a8a148b4c2ad990f5af1604d5855b80c6e95f39cd371a43a591b7f1
+  data.tar.gz: bc7644a08678136d91696a68e0ad670f4f04d41772f36ba1bd806ebe45f23b04
 SHA512:
-  metadata.gz: 69ad3ae158a8e478864db65dc808152d4b1b16bdc8779b1a651f59f199167daf00d2aa10018c5f65d5e619bbca4c09e99bc319ca736eed57023d61e6067ea365
-  data.tar.gz: 18ca63e176e12ea50a5168e835a2eddfa66c8f522943d42e6d895d2f3e05d0cf6d396ab28d79f98898c91670b618cc27dbad5fa0bc9129a3edcfc3f74f5db029
+  metadata.gz: a39a8adc0c72288db5bd08e2483cefb701db9c2122fe1b4012c19bef07c7d048fed7f6e051473a9b4b6c80e321e4a781a16543d40f3e569f23c31f420a5117b6
+  data.tar.gz: 3ddcc914e3143a02a4582d6f525417c3012ae4eafc9ae889d5935223f6173afb4fb5ff3a40dc6c9caf95dfbf7a3c5be8e7bc4890efb385867ef5fa6f3ccbfb9e

data/lib/brick/config.rb

@@ -97,6 +97,15 @@ module Brick
       @mutex.synchronize { @has_ones = hos }
     end
 
+    # Polymorphic associations
+    def polymorphics
+      @mutex.synchronize { @polymorphics }
+    end
+
+    def polymorphics=(polys)
+      @mutex.synchronize { @polymorphics = polys }
+    end
+
     def model_descrips
       @mutex.synchronize { @model_descrips ||= {} }
     end

data/lib/brick/extensions.rb

@@ -26,18 +26,13 @@
 
 # colour coded origins
 
-# Drag something like TmfModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = section / etc
+# Drag something like HierModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = section / etc
 
 # Support for Postgres / MySQL enums (add enum to model, use model enums to make a drop-down in the UI)
 
 # Currently quadrupling up routes
 
 
-# From the North app:
-# undefined method `built_in_role_path' when referencing show on a subclassed STI:
-#  http://localhost:3000/roles/3?_brick_schema=cust1
-
-
 # ==========================================================
 # Dynamically create model or controller classes when needed
 # ==========================================================
@@ -57,6 +52,14 @@ 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
@@ -79,8 +82,8 @@ module ActiveRecord
       dsl
     end
 
-    # Pass in true or a JoinArray
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {})
+    # 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)
       members = []
@@ -92,12 +95,17 @@ module ActiveRecord
           if bracket_name
             if ch == ']' # Time to process a bracketed thing?
               parts = bracket_name.split('.')
-              first_parts = parts[0..-2].map { |part| klass = klass.reflect_on_association(part_sym = part.to_sym).klass; part_sym }
+              first_parts = parts[0..-2].map do |part|
+                klass = klass.reflect_on_association(part_sym = part.to_sym).klass
+                part_sym
+              end
               parts = prefix + first_parts + [parts[-1]]
               if parts.length > 1
-                s = build_array
-                parts[0..-3].each { |v| s = s[v.to_sym] }
-                s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
+                unless is_polymorphic
+                  s = build_array
+                  parts[0..-3].each { |v| s = s[v.to_sym] }
+                  s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
+                end
                 translations[parts[0..-2].join('.')] = klass
               end
               members << parts
@@ -120,8 +128,8 @@ module ActiveRecord
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
     # Object property names can be referenced in square brackets like this:
     # { 'User' => '[profile.firstname] [profile.lastname]' }
-    def brick_descrip
-      self.class.brick_descrip(self)
+    def brick_descrip(data = nil, pk_alias = nil)
+      self.class.brick_descrip(self, data, pk_alias)
     end
 
     def self.brick_descrip(obj, data = nil, pk_alias = nil)
@@ -141,11 +149,7 @@ module ActiveRecord
                         this_obj = obj
                         bracket_name.split('.').each do |part|
                           obj_name += ".#{part}"
-                          this_obj = if caches.key?(obj_name)
-                                       caches[obj_name]
-                                     else
-                                       (caches[obj_name] = this_obj&.send(part.to_sym))
-                                     end
+                          this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
                         end
                         this_obj&.to_s || ''
                       end
@@ -165,12 +169,17 @@ module ActiveRecord
       end
       if is_brackets_have_content
         output
-      elsif pk_alias
-        if (id = pk_alias.map { |pk_alias_part| obj.send(pk_alias_part) })
+      elsif (pk_alias ||= primary_key)
+        pk_alias = [pk_alias] unless pk_alias.is_a?(Array)
+        id = []
+        pk_alias.each do |pk_alias_part|
+          if (pk_part = obj.send(pk_alias_part))
+            id << pk_part
+          end
+        end
+        if id.present?
           "#{klass.name} ##{id.join(', ')}"
         end
-      # elsif klass.primary_key
-      #   "#{klass.name} ##{obj.send(klass.primary_key)}"
       else
         obj.to_s
       end
@@ -184,10 +193,21 @@ module ActiveRecord
       model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
     end
 
+    def self.brick_import_template
+      template = constants.include?(:IMPORT_TEMPLATE) ? self::IMPORT_TEMPLATE : suggest_template(false, false, 0)
+      # Add the primary key to the template as being unique (unless it's already there)
+      template[:uniques] = [pk = primary_key.to_sym]
+      template[:all].unshift(pk) unless template[:all].include?(pk)
+      template
+    end
+
   private
 
     def self._brick_get_fks
-      @_brick_get_fks ||= reflect_on_all_associations.select { |a2| a2.macro == :belongs_to }.map(&:foreign_key)
+      @_brick_get_fks ||= reflect_on_all_associations.select { |a2| a2.macro == :belongs_to }.each_with_object([]) do |bt, s|
+        s << bt.foreign_key
+        s << bt.foreign_type if bt.polymorphic?
+      end
     end
   end
 
@@ -289,7 +309,11 @@ module ActiveRecord
         bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
         bts.each do |_k, bt|
           # join_array will receive this relation name when calling #brick_parse_dsl
-          bt_descrip[bt.first] = [bt.last, bt.last.brick_parse_dsl(join_array, bt.first, translations)]
+          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) }
+                                 else
+                                   { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
+                                 end
         end
         skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
         hms.each do |k, hm|
@@ -307,7 +331,7 @@ module ActiveRecord
         when 2
           assoc_name = ks.first.to_sym
           # Make sure it's a good association name and that the model has that column name
-          next unless klass.reflect_on_association(assoc_name)&.klass&.columns&.any? { |col| col.name == ks.last }
+          next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(ks.last)
 
           join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
         end
@@ -323,23 +347,31 @@ module ActiveRecord
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
         bt_columns = bt_descrip.each_with_object([]) do |v, s|
-          tbl_name = field_tbl_names[v.first][v.last.first] ||= shift_or_first(chains[v.last.first])
-          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(v.first) # was tbl_name
-            # 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
-            end
-            v.last << id_for_tables[v.first]
-          end
-          if (col_name = v.last[1].last&.last)
+          v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
+            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
-            v.last[1].map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
+            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])
-              # col_name is weak when there are multiple, using sel_col.last instead
+
               selects << "#{"#{field_tbl_name}.#{sel_col.last}"} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
-              v.last[1][idx] << col_alias
+              v1[idx] << col_alias
             end
+            # end
+
+            if (id_col = k1.primary_key) && !id_for_tables.key?(v.first) # was tbl_name
+              # 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
+              end
+              v1 << id_for_tables[v.first]
+            end
+
           end
         end
         join_array.each do |assoc_name|
@@ -354,25 +386,30 @@ module ActiveRecord
       hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
-                          fk_col = (associative = associatives[hm.name]).foreign_key
-                          hm.foreign_key
-                        else
-                          fk_col = hm.foreign_key
-                          hm.klass.primary_key || '*'
-                        end
+                         fk_col = (associative = associatives[hm.name]).foreign_key
+                         hm.foreign_key
+                       else
+                         fk_col = hm.foreign_key
+                         poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
+                         hm.klass.primary_key || '*'
+                       end
         tbl_alias = "_br_#{hm.name}"
         pri_tbl = hm.active_record
+        on_clause = []
         if fk_col.is_a?(Array) # Composite key?
-          on_clause = []
           fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_tbl.primary_key[idx]}" }
-          joins!("LEFT OUTER
-JOIN (SELECT #{fk_col.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.name || hm.klass.table_name} GROUP BY #{(1..fk_col.length).to_a.join(', ')}) AS #{tbl_alias}
-  ON #{on_clause.join(' AND ')}")
+          selects = fk_col.dup
         else
-          joins!("LEFT OUTER
-JOIN (SELECT #{fk_col}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.name || hm.klass.table_name} GROUP BY 1) AS #{tbl_alias}
-  ON #{tbl_alias}.#{fk_col} = #{pri_tbl.table_name}.#{pri_tbl.primary_key}")
+          selects = [fk_col]
+          on_clause << "#{tbl_alias}.#{fk_col} = #{pri_tbl.table_name}.#{pri_tbl.primary_key}"
+        end
+        if poly_type
+          selects << poly_type
+          on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
+        join_clause = "LEFT OUTER
+JOIN (SELECT #{selects.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name} GROUP BY #{(1..selects.length).to_a.join(', ')}) AS #{tbl_alias}"
+        joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
       where!(wheres) unless wheres.empty?
       wheres unless wheres.empty? # Return the specific parameters that we did use
@@ -469,7 +506,7 @@ class Object
       # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
       # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
       # If the file really exists, go and snag it:
-      if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = self.name&.split('::'))
+      if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = (self.name || class_name)&.split('::'))
         filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
       end
       if is_found
@@ -582,112 +619,132 @@ class Object
           hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
             # The key in each hash entry (fk.first) is the constraint name
             inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
-            options = {}
-            singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
-            macro = if assoc[:is_bt]
-                      # Try to take care of screwy names if this is a belongs_to going to an STI subclass
-                      assoc_name = if (primary_class = assoc.fetch(:primary_class, nil)) &&
-                                      sti_inverse_assoc = primary_class.reflect_on_all_associations.find do |a|
-                                        a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key
-                                      end
-                                     sti_inverse_assoc.options[:inverse_of]&.to_s || assoc_name
-                                   else
-                                     assoc[:assoc_name]
-                                   end
-                      need_class_name = singular_table_name.underscore != assoc_name
-                      need_fk = "#{assoc_name}_id" != assoc[:fk]
-                      if (inverse = assoc[:inverse])
-                        inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], inverse)
-                        if (has_ones = ::Brick.config.has_ones&.fetch(inverse[:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
-                          inverse_assoc_name = if has_ones[singular_inv_assoc_name]
-                                                 need_inverse_of = true
-                                                 has_ones[singular_inv_assoc_name]
-                                               else
-                                                 singular_inv_assoc_name
-                                               end
-                        end
-                      end
-                      :belongs_to
-                    else
-                      # 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)
-                      need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
-                      # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
-                      if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
-                        assoc_name = if (custom_assoc_name = has_ones[singular_assoc_name])
-                                       need_class_name = custom_assoc_name != singular_assoc_name
-                                       custom_assoc_name
-                                     else
-                                       singular_assoc_name
-                                     end
-                        :has_one
-                      else
-                        :has_many
-                      end
-                    end
-            # Figure out if we need to specially call out the class_name and/or foreign key
-            # (and if either of those then definitely also a specific inverse_of)
-            options[:class_name] = assoc[:primary_class]&.name || singular_table_name.camelize if need_class_name
-            # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
-            if need_fk # Funky foreign key?
-              options[:foreign_key] = if assoc[:fk].is_a?(Array)
-                                        assoc_fk = assoc[:fk].uniq
-                                        assoc_fk.length < 2 ? assoc_fk.first : assoc_fk
-                                      else
-                                        assoc[:fk].to_sym
-                                      end
-            end
-            options[:inverse_of] = inverse_assoc_name.to_sym if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of)
-
-            # Prepare a list of entries for "has_many :through"
-            if macro == :has_many
-              relations[assoc[:inverse_table]][:hmt_fks].each do |k, hmt_fk|
-                next if k == assoc[:fk]
-
-                hmts[ActiveSupport::Inflector.pluralize(hmt_fk.last)] << [assoc, hmt_fk.first]
-              end
+            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)
             end
-
-            # And finally create a has_one, has_many, or belongs_to for this association
-            assoc_name = assoc_name.to_sym
-            code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
-            self.send(macro, assoc_name, **options)
             hmts
           end
           hmts.each do |hmt_fk, fks|
             fks.each do |fk|
-              source = nil
-              this_hmt_fk = if fks.length > 1
-                              singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
-                              source = fk.last
-                              through = fk.first[:alternate_name].pluralize
-                              "#{singular_assoc_name}_#{hmt_fk}"
-                            else
-                              source = fk.last unless hmt_fk.singularize == fk.last
-                              through = fk.first[:assoc_name].pluralize
-                              hmt_fk
-                            end
-              code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
+              through = fk.first[:assoc_name]
+              hmt_name = if fks.length > 1
+                           if fks[0].first[:inverse][:assoc_name] == fks[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
+                             "#{hmt_fk}_through_#{fk.first[:assoc_name]}"
+                           else # Use BT names to provide uniqueness
+                             through = fk.first[:alternate_name].pluralize
+                             singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
+                             "#{singular_assoc_name}_#{hmt_fk}"
+                           end
+                         else
+                           hmt_fk
+                         end
+              source = fk.last unless hmt_name.singularize == fk.last
+              code << "  has_many :#{hmt_name}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
               options = { through: assoc_name }
               options[:source] = source.to_sym if source
-              self.send(:has_many, this_hmt_fk.to_sym, **options)
-            end
-          end
-          # Not NULLables
-          relation[:cols].each do |col, datatype|
-            if (datatype[3] && ar_pks.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
-               ::Brick.config.not_nullables.include?("#{matching}.#{col}")
-              code << "  validates :#{col}, presence: true\n"
-              self.send(:validates, col.to_sym, { presence: true })
+              self.send(:has_many, hmt_name.to_sym, **options)
             end
           end
+          # # 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)) ||
+          #      ::Brick.config.not_nullables.include?("#{matching}.#{col}")
+          #     code << "  validates :#{col}, not_null: true\n"
+          #     self.send(:validates, col.to_sym, { not_null: true })
+          #   end
+          # end
         end
         code << "end # model #{model_name}\n\n"
       end # class definition
       [built_model, code]
     end
 
+    def build_bt_or_hm(relations, model_name, relation, hmts, assoc, inverse_assoc_name, inverse_table, code)
+      singular_table_name = inverse_table&.singularize
+      options = {}
+      macro = if assoc[:is_bt]
+                # Try to take care of screwy names if this is a belongs_to going to an STI subclass
+                assoc_name = if (primary_class = assoc.fetch(:primary_class, nil)) &&
+                               sti_inverse_assoc = primary_class.reflect_on_all_associations.find do |a|
+                                 a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key
+                               end
+                               sti_inverse_assoc.options[:inverse_of]&.to_s || assoc_name
+                             else
+                               assoc[:assoc_name]
+                             end
+                if assoc.key?(:polymorphic)
+                  options[:polymorphic] = true
+                else
+                  need_class_name = singular_table_name.underscore != assoc_name
+                  need_fk = "#{assoc_name}_id" != assoc[:fk]
+                end
+                if (inverse = assoc[:inverse])
+                  inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[inverse_table], inverse)
+                  has_ones = ::Brick.config.has_ones&.fetch(inverse[:alternate_name].camelize, nil)
+                  if has_ones&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
+                    inverse_assoc_name = if has_ones[singular_inv_assoc_name]
+                                           need_inverse_of = true
+                                           has_ones[singular_inv_assoc_name]
+                                         else
+                                           singular_inv_assoc_name
+                                         end
+                  end
+                end
+                :belongs_to
+              else
+                # 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)
+                else
+                  need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
+                end
+                # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
+                if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
+                  assoc_name = if (custom_assoc_name = has_ones[singular_assoc_name])
+                                 need_class_name = custom_assoc_name != singular_assoc_name
+                                 custom_assoc_name
+                               else
+                                 singular_assoc_name
+                               end
+                  :has_one
+                else
+                  :has_many
+                end
+              end
+      # Figure out if we need to specially call out the class_name and/or foreign key
+      # (and if either of those then definitely also a specific inverse_of)
+      options[:class_name] = assoc[:primary_class]&.name || singular_table_name.camelize if need_class_name
+      # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
+      if need_fk # Funky foreign key?
+        options[:foreign_key] = if assoc[:fk].is_a?(Array)
+                                  assoc_fk = assoc[:fk].uniq
+                                  assoc_fk.length < 2 ? assoc_fk.first : assoc_fk
+                                else
+                                  assoc[:fk].to_sym
+                                end
+      end
+      options[:inverse_of] = inverse_assoc_name.to_sym if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of)
+
+      # Prepare a list of entries for "has_many :through"
+      if macro == :has_many
+        relations[inverse_table][:hmt_fks].each do |k, hmt_fk|
+          next if k == assoc[:fk]
+
+          hmts[ActiveSupport::Inflector.pluralize(hmt_fk.last)] << [assoc, hmt_fk.first]
+        end
+      end
+      # And finally create a has_one, has_many, or belongs_to for this association
+      assoc_name = assoc_name.to_sym
+      code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
+      self.send(macro, assoc_name, **options)
+    end
+
     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)
@@ -700,9 +757,22 @@ class Object
         code << "    @#{table_name} = #{model.name}#{model.primary_key ? ".order(#{model.primary_key.inspect})" : '.all'}\n"
         code << "    @#{table_name}.brick_select(params)\n"
         code << "  end\n"
+        self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
           ::Brick.set_db_schema(params)
-          ar_relation = model.all # model.primary_key ? model.order(model.primary_key) : model.all
+          if request.format == :csv # Asking for a template?
+            require 'csv'
+            exported_csv = CSV.generate(force_quotes: false) do |csv_out|
+              model.df_export(model.brick_import_template).each { |row| csv_out << row }
+            end
+            render inline: exported_csv, content_type: request.format
+            return
+          elsif request.format == :js # Asking for JSON?
+            render inline: model.df_export(model.brick_import_template).to_json, content_type: request.format
+            return
+          end
+
+          ar_relation = model.primary_key ? model.order("#{model.table_name}.#{model.primary_key}") : 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?
@@ -739,6 +809,22 @@ class Object
             code << "  end\n"
             self.define_method :update do
               ::Brick.set_db_schema(params)
+
+              if request.format == :csv # Importing CSV?
+                require 'csv'
+                # See if internally it's likely a TSV file (tab-separated)
+                tab_counts = []
+                5.times { tab_counts << request.body.readline.count("\t") unless request.body.eof? }
+                request.body.rewind
+                separator = "\t" if tab_counts.length > 0 && tab_counts.uniq.length == 1 && tab_counts.first > 0
+                result = model.df_import(CSV.parse(request.body, { col_sep: separator || :auto }), model.brick_import_template)
+                # render inline: exported_csv, content_type: request.format
+                return
+              # elsif request.format == :js # Asking for JSON?
+              #   render inline: model.df_export(true).to_json, content_type: request.format
+              #   return
+              end
+
               instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(params[:id].split(','))))
               obj = obj.first if obj.is_a?(Array)
               obj.send(:update, send(params_name = params_name.to_sym))
@@ -971,14 +1057,19 @@ module Brick
   # rubocop:enable Style/CommentedKeyword
 
   class << self
-    def _add_bt_and_hm(fk, relations = nil)
-      relations ||= ::Brick.relations
+    def _add_bt_and_hm(fk, relations, is_polymorphic = false)
       bt_assoc_name = fk[1].underscore
       bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
 
       bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
-      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
+      # %%% 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
 
       unless (cnstr_name = fk[3])
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
@@ -993,7 +1084,7 @@ module Brick
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
           return
         end
-        unless (cols = relations[fk[0]][:cols]).key?(fk[1])
+        unless (cols = relations[fk[0]][:cols]).key?(fk[1]) || (is_polymorphic && cols.key?("#{fk[1]}_id") && cols.key?("#{fk[1]}_type"))
           columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
           return
@@ -1008,10 +1099,17 @@ module Brick
         end
       end
       if (assoc_bt = bts[cnstr_name])
-        assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[1]] : assoc_bt[:fk].concat(fk[1])
-        assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
+        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])
+          assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
+        end
       else
-        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: primary_table }
+        inverse_table = [primary_table] if is_polymorphic
+        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: inverse_table || primary_table }
+        assoc_bt[:polymorphic] = true if is_polymorphic
       end
       if is_class
         # For use in finding the proper :source for a HMT association that references an STI subclass
@@ -1028,6 +1126,7 @@ module Brick
         assoc_hm[:inverse] = assoc_bt
       else
         assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+        assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
       end

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

@@ -38,6 +38,9 @@ module Brick
 
         # Has one relationships
         ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
+
+        # Polymorphic associations
+        ::Brick.polymorphics = app.config.brick.fetch(:polymorphics, nil)
       end
 
       # After we're initialized and before running the rest of stuff, put our configuration in place
@@ -64,12 +67,14 @@ module Brick
               is_template_exists
             end
 
-            def path_keys(fk_name, obj_name, pk)
-              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}"]]
-              end.map { |x| "#{x.first}: #{x.last}"}.join(', ')
+            def path_keys(hm_assoc, fk_name, obj_name, pk)
+              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}"]]
+                     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(', ')
             end
 
             alias :_brick_find_template :find_template
@@ -80,6 +85,7 @@ module Brick
               pk = @_brick_model.primary_key
               obj_name = model_name.underscore
               table_name = model_name.pluralize.underscore
+              template_link = nil
               bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
               hms_columns = [] # Used for 'index'
               skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
@@ -96,15 +102,17 @@ module Brick
                                    set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
                                               'nil'
                                             else
-                                              "#{obj_name}._br_#{assoc_name}_ct || 0"
+                                              # Postgres column names are limited to 63 characters
+                                              attrib_name = "_br_#{assoc_name}_ct"[0..62]
+                                              "#{obj_name}.#{attrib_name} || 0"
                                             end
 "<%= ct = #{set_ct}
-     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
+     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
                                  else # has_one
 "<%= 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_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}&.first&", pk)} }) %>\n"
                 end
                 s << hm_stuff
               end
@@ -115,6 +123,13 @@ module Brick
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
                               .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
               css = +"<style>
+#dropper {
+  background-color: #eee;
+}
+#btnImport {
+  display: none;
+}
+
 table {
   border-collapse: collapse;
   margin: 25px 0;
@@ -195,7 +210,16 @@ def hide_bcrypt(val)
 end %>"
 
               if ['index', 'show', 'update'].include?(args.first)
-                css << "<% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} } %>"
+                css << "<% bts = { #{
+                  bts.each_with_object([]) do |v, s|
+                    foreign_models = if v.last[1].is_a?(Array)
+                                       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}]]"
+                  end.join(', ')
+                } } %>"
               end
 
               # %%% When doing schema select, if there's an ID then remove it, or if we're on a new page go to index
@@ -260,11 +284,102 @@ function changeout(href, param, value) {
                                   elsif pk
                                     "#{obj_name}.#{pk}"
                                   end
+                         if Object.const_defined?('DutyFree')
+                           template_link = "
+  <%= link_to 'CSV', #{table_name}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
+  <div id=\"dropper\" contenteditable=\"true\"></div>
+  <input type=\"button\" id=\"btnImport\" value=\"Import\">
+
+<script>
+  var dropperDiv = document.getElementById(\"dropper\");
+  var btnImport = document.getElementById(\"btnImport\");
+  var droppedTSV;
+  if (dropperDiv) { // Other interesting events: blur keyup input
+    dropperDiv.addEventListener(\"paste\", function (evt) {
+      droppedTSV = evt.clipboardData.getData('text/plain');
+      var html = evt.clipboardData.getData('text/html');
+      var tbl = html.substring(html.indexOf(\"<tbody>\") + 7, html.lastIndexOf(\"</tbody>\"));
+      console.log(tbl);
+      btnImport.style.display = droppedTSV.length > 0 ? \"block\" : \"none\";
+    });
+    btnImport.addEventListener(\"click\", function () {
+      fetch(changeout(<%= #{obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'text/tab-separated-values' },
+        body: droppedTSV
+      }).then(function (tsvResponse) {
+        btnImport.style.display = \"none\";
+        console.log(\"toaster\", tsvResponse);
+      });
+    });
+  }
+  var sheetUrl;
+  var spreadsheetId;
+  var sheetsLink = document.getElementById(\"sheetsLink\");
+  function gapiLoaded() {
+    // Have a click on the sheets link to bring up the sign-in window.  (Must happen from some kind of user click.)
+    sheetsLink.addEventListener(\"click\", async function (evt) {
+      evt.preventDefault();
+      await gapi.load(\"client\", function () {
+        gapi.client.init({ // Load the discovery doc to initialize the API
+          clientId: \"487319557829-fgj4u660igrpptdji7ev0r5hb6kh05dh.apps.googleusercontent.com\",
+          scope: \"https://www.googleapis.com/auth/spreadsheets https://www.googleapis.com/auth/drive.file\",
+          discoveryDocs: [\"https://sheets.googleapis.com/$discovery/rest?version=v4\"]
+        }).then(function () {
+          gapi.auth2.getAuthInstance().isSignedIn.listen(updateSignInStatus);
+          updateSignInStatus(gapi.auth2.getAuthInstance().isSignedIn.get());
+        });
+      });
+    });
+  }
+
+  async function updateSignInStatus(isSignedIn) {
+    if (isSignedIn) {
+      console.log(\"turds!\");
+      await gapi.client.sheets.spreadsheets.create({
+        properties: {
+          title: #{table_name.inspect},
+        },
+        sheets: [
+          // sheet1, sheet2, sheet3
+        ]
+      }).then(function (response) {
+        sheetUrl = response.result.spreadsheetUrl;
+        spreadsheetId = response.result.spreadsheetId;
+        sheetsLink.setAttribute(\"href\", sheetUrl); // response.result.spreadsheetUrl
+        console.log(\"x1\", sheetUrl);
+
+        // Get JSON data
+        fetch(changeout(<%= #{table_name}_path(format: :js).inspect.html_safe %>, \"_brick_schema\", brickSchema)).then(function (response) {
+          response.json().then(function (data) {
+            gapi.client.sheets.spreadsheets.values.append({
+              spreadsheetId: spreadsheetId,
+              range: \"Sheet1\",
+              valueInputOption: \"RAW\",
+              insertDataOption: \"INSERT_ROWS\"
+            }, {
+              range: \"Sheet1\",
+              majorDimension: \"ROWS\",
+              values: data,
+            }).then(function (response2) {
+  //            console.log(\"beefcake\", response2);
+            });
+          });
+        });
+      });
+      window.open(sheetUrl, '_blank');
+    }
+  }
+</script>
+<script async defer src=\"https://apis.google.com/js/api.js\" onload=\"gapiLoaded()\"></script>
+"
+                         end
 "#{css}
 <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.pluralize}</h1>
+<h1>#{model_name.pluralize}</h1>#{template_link}
+
 <% 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}
@@ -272,10 +387,13 @@ function changeout(href, param, value) {
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
-      BT <%= bt[1].bt_link(bt.first) %>
-    <% else %>
-      <%= col %>
-    <% end %>
+         BT <%
+         bt[1].each do |bt_pair| %><%=
+           bt_pair.first.bt_link(bt.first) %> <%
+         end %><%
+       else %><%=
+         col %><%
+       end %>
     </th>
   <% end %>
   <%# Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name %>
@@ -285,23 +403,32 @@ function changeout(href, param, value) {
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if pk}
+    <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.end_with?('_ct')) %>
+      <% 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'))) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%# binding.pry # Postgres column names are limited to 63 characters!!! %>
-        <% bt_txt = bt[1].brick_descrip(#{obj_name}, @_brick_bt_descrip[bt.first][1].map { |z| #{obj_name}.send(z.last[0..62]) }, @_brick_bt_descrip[bt.first][2]) %>
-        <% bt_id_col = @_brick_bt_descrip[bt.first][2]; bt_id = #{obj_name}.send(*bt_id_col) if bt_id_col&.present? %>
-        <%= bt_id ? link_to(bt_txt, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
-        <%#= Previously was:  bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
+        <%# binding.pry # Postgres column names are limited to 63 characters %>
+        <% if (pairs = bt[1].length > 1)
+             bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
+             # descrips = @_brick_bt_descrip[bt.first][bt_class]
+             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 %>
+          <%#= 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 %>
         <%= hide_bcrypt(val) %>
       <% end %>
       </td>
     <% end %>
-    <td>#{hms_columns.join('</td><td>')}</td>
-    <!-- td>X</td -->
+    #{hms_columns.each_with_object(+'') { |hm_col, s| s << "<td>#{hm_col}</td>" }}
   </tr>
   </tbody>
   <% end %>
@@ -318,33 +445,47 @@ function changeout(href, param, value) {
 <%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
 <% if obj %>
   <%= # path_options = [obj.#{pk}]
-   # path_options << { '_brick_schema':  } if
-   # url = send(:#{model_name.underscore}_path, obj.#{pk})
-   form_for(obj.becomes(#{model_name})) do |f| %>
+    # path_options << { '_brick_schema':  } if
+    # url = send(:#{model_name.underscore}_path, obj.#{pk})
+    form_for(obj.becomes(#{model_name})) do |f| %>
   <table>
-  <% @#{obj_name}.first.attributes.each do |k, val| %>
+  <% has_fields = false
+    @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
+    <%# %%% Accommodate composite keys %>
     <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
-    <% 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].name
-      # %%% Only do this if the user has permissions to edit this bt field
-      if bt.length < 4
-        bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
-        bt[1].order(:#{pk}).each { |obj| option_detail << [obj.brick_descrip, obj.#{pk}] }
-      end %>
-      BT <%= bt[1].bt_link(bt.first) %>
+    <% 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 }
+          # 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)] }
+        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 << (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)] }
+        end %>
+        BT <%= bt_class.bt_link(bt.first) %>
     <% else %>
       <%= k %>
     <% end %>
     </th>
     <td>
-    <% if (bt = bts[k]) # bt_obj.brick_descrip
+    <% if bt
       html_options = { prompt: \"Select #\{bt_name\}\" }
       html_options[:class] = 'dimmed' unless val %>
-      <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
-      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_path_base = bt_name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+      <%= 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 %>
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
@@ -365,8 +506,12 @@ function changeout(href, param, value) {
     <% end %>
     </td>
     </tr>
-    <% end %>
+  <% end
+  if has_fields %>
     <tr><td colspan=\"2\" class=\"right\"><%= f.submit %></td></tr>
+  <% else %>
+    <tr><td colspan=\"2\">(No displayable fields)</td></tr>
+  <% end %>
   </table>
   <% end %>
 
@@ -380,6 +525,7 @@ function changeout(href, param, value) {
           <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>
           <% end %>
         <% end %>
@@ -392,6 +538,7 @@ 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')
@@ -408,7 +555,7 @@ function changeout(href, param, value) {
         end
 
         # Just in case it hadn't been done previously when we tried to load the brick initialiser,
-        # go make sure we've loaded additional references (virtual foreign keys).
+        # go make sure we've loaded additional references (virtual foreign keys and polymorphic associations).
         ::Brick.load_additional_references
       end
     end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -103,11 +103,17 @@ 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] = [a.name, a.klass]
+          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]
+                                   else
+                                     [a.name, a.klass]
+                                   end
         when :has_many, :has_one # This gets has_many as well as has_many :through
           # %%% weed out ones that don't have an available model to reference
           s.last[a.name] = a
@@ -126,9 +132,7 @@ module Brick
           skip_hms[hmt.last.name] = nil
         end
       end
-      skip_hms.each do |k, _v|
-        puts hms.delete(k).inspect
-      end
+      skip_hms.each { |k, _v| hms.delete(k) }
       [bts, hms, associatives]
     end
 
@@ -258,6 +262,11 @@ module Brick
       end
     end
 
+    # Polymorphic associations
+    def polymorphics=(polys)
+      Brick.config.polymorphics = polys || {}
+    end
+
     # DSL templates for individual models to provide prettier descriptions of objects
     # @api public
     def model_descrips=(descrips)
@@ -276,8 +285,18 @@ module Brick
     def load_additional_references
       return if @_additional_references_loaded
 
-      if (ars = ::Brick.config.additional_references)
-        ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2]) }
+      relations = ::Brick.relations
+      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)
+          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)
+            end
+          end
+        end
         @_additional_references_loaded = true
       end
 

data/lib/generators/brick/install_generator.rb

@@ -157,6 +157,10 @@ 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']
+
 # # 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
 # # name and action you wish in order to override this and have that be the default route when none other has been

metadata

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