brick 1.0.123 → 1.0.125

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baad039242ee5623097ad6170fec07e5feb0eb2fed6d41a9079f0775cccaceea
-  data.tar.gz: 603377f6b2c4437c448630bce6581d3650b8dfc13187e82afbaab1d425d171e2
+  metadata.gz: dc3caefac264427d0a4a7efa11160fc3b7c1cc6c82afa01bf7340941dbab18e1
+  data.tar.gz: 7d9aebd13fe256d43ee3ec24f94065a64ab4955e3ee379023352013db59fe3ba
 SHA512:
-  metadata.gz: 1f4e48c1a437684929a81ace3e75ab15bb627c006680dba5a7454825fba358142560712f016bf944575aefeb27655716c3212d72a2b9b5a083a09cd2dfa8537c
-  data.tar.gz: ea9c376866230e4c2bab7b6c34dfc435a8cf81b568bc22af3a0e69497accca1620152ae311eab6c96649b79ecedf978b880afa88888dc6d1c4d3700bc3ef3060
+  metadata.gz: c02e8bdceca8f726d24a8f7eddb6057427d2e31c3db3934bd72da0393509aaf2d5e7246ba65e8bdd773fc3d995c538567137dec729eb2d062ba0f7e006ace7c6
+  data.tar.gz: c6061b00b761638ebd0f9750423643615c08dffb9c62bec423d1bf5c047dcfa82c9b2bccaea1491d9f7a4c23932b9299be1254e708e26ca624165a5695557c63

data/lib/brick/extensions.rb

@@ -68,6 +68,12 @@ module ActiveRecord
           self
         end
       end
+
+      def json_column?(col)
+        col.type == :json || ::Brick.config.json_columns[table_name]&.include?(col.name) ||
+        ((attr_types = attribute_types[col.name]).respond_to?(:coder) &&
+         (attr_types.coder.is_a?(Class) ? attr_types.coder : attr_types.coder&.class)&.name&.end_with?('JSON'))
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -638,6 +644,7 @@ module ActiveRecord
       # Add derived table JOIN for the has_many counts
       nix = []
       klass._br_hm_counts.each do |k, hm|
+        num_bt_things = 0
         count_column = if hm.options[:through]
                          # Build the chain of JOINs going to the final destination HMT table
                          # (Usually just one JOIN, but could be many.)
@@ -668,7 +675,9 @@ module ActiveRecord
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             link_back << nm
-                                            "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
+                                            num_bt_things += 1
+                                            # puts "BT #{a.table_name}"
+                                            "ON br_t#{idx}.#{a.active_record.primary_key} = br_t#{idx - 1}.#{a.foreign_key}"
                                           elsif src_ref.options[:as]
                                             "ON br_t#{idx}.#{src_ref.type} = '#{src_ref.active_record.name}'" + # "polymorphable_type"
                                             " AND br_t#{idx}.#{src_ref.foreign_key} = br_t#{idx - 1}.id"
@@ -679,18 +688,19 @@ module ActiveRecord
                                               bail_out = true
                                               break
                                               # "ON br_t#{idx}.#{a.foreign_type} = '#{src_ref.options[:source_type]}' AND " \
-                                              #   "br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
+                                              #   "br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.#{a.active_record.primary_key}"
                                             else # Works for HMT through a polymorphic HO
                                               link_back << hmt_assoc.source_reflection.inverse_of&.name # Some polymorphic "_able" thing
                                               "ON br_t#{idx - 1}.#{a.foreign_type} = '#{src_ref.options[:source_type]}' AND " \
-                                                "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.id"
+                                                "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.#{a.active_record.primary_key}"
                                             end
                                           else # Standard has_many or has_one
+                                            # puts "HM #{a.table_name}"
                                             # binding.pry unless (
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             # )
                                             link_back << nm # if nm
-                                            "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
+                                            "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.#{a.active_record.primary_key}"
                                           end
                            link_back.unshift(a.source_reflection.name)
                            [a.table_name, a.foreign_key, a.source_reflection.macro]
@@ -708,7 +718,13 @@ module ActiveRecord
                            # binding.pry if link_back.length > 2
                            "br_t#{idx}.#{hm.foreign_key}"
                          else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
-                           # binding.pry if link_back.length > 2
+                           # %%% Currently flaky, so will revisit this soon, probably while implementing the whole link_back architecture
+                           if num_bt_things > 1
+                             # binding.pry
+                             nix << k
+                             next
+                           end
+
                            "br_t#{idx}.#{src_ref.active_record.primary_key}"
                          end
                        else
@@ -846,8 +862,7 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
         if ::Brick.sti_models.key?(type_name ||= name)
-          # Used to be:  ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
-          _brick_find_sti_class(type_name)
+          ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
         else
           # This auto-STI is more of a brute-force approach, building modules where needed
           # The more graceful alternative is the overload of ActiveSupport::Dependencies#autoload_module! found below
@@ -855,9 +870,13 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
           module_prefixes = type_name.split('::')
           module_prefixes.unshift('') unless module_prefixes.first.blank?
           module_name = module_prefixes[0..-2].join('::')
-          if (snp = ::Brick.config.sti_namespace_prefixes)&.key?("::#{module_name}::") || snp&.key?("#{module_name}::") ||
+          if (base_name = ::Brick.config.sti_namespace_prefixes&.fetch("#{module_name}::", nil)) ||
              File.exist?(candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
-            _brick_find_sti_class(type_name) # Find this STI class normally
+            if base_name
+              base_name == "::#{name}" ? self : base_name.constantize
+            else
+              _brick_find_sti_class(type_name) # Find this STI class normally
+            end
           else
             # Build missing prefix modules if they don't yet exist
             this_module = Object
@@ -978,6 +997,8 @@ Module.class_exec do
                     end
                     Object
                   else
+                    sti_base = (::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::#{requested}", nil) ||
+                                ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil))&.constantize
                     self
                   end
     # puts "#{self.name} - #{args.first}"
@@ -985,7 +1006,7 @@ Module.class_exec do
     if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) &&
         # Reset `possible` if it's a controller request that's not a perfect match
         # Was:  (possible = nil)  but changed to #local_variable_set in order to suppress the "= should be ==" warning
-        (possible.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
+        (possible&.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
        # Try to require the respective Ruby file
        ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
                     (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
@@ -995,9 +1016,11 @@ Module.class_exec do
        # If any class has turned up so far (and we're not in the middle of eager loading)
        # then return what we've found.
        (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
-      if (!brick_root && (filename || possible.instance_of?(Class))) ||
-         (possible.instance_of?(Module) && possible&.module_parent == self) ||
-         (possible.instance_of?(Class) && possible == self) # Are we simply searching for ourselves?
+      if ((!brick_root && (filename || possible.instance_of?(Class))) ||
+          (possible.instance_of?(Module) && possible&.module_parent == self) ||
+          (possible.instance_of?(Class) && possible == self)) && # Are we simply searching for ourselves?
+         # Skip when what we found as `possible` is not related to the base class of an STI model
+         (!sti_base || possible.is_a?(sti_base))
         return possible
       end
     end
@@ -1129,7 +1152,8 @@ class Object
 
     def build_model(relations, base_module, base_name, class_name, inheritable_name = nil)
       tnp = ::Brick.config.table_name_prefixes&.find { |p| p.last == base_module.name }&.first
-      if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+      if (base_model = (::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::#{class_name}", nil) || # Are we part of an auto-STI namespace? ...
+                        ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil))&.constantize) ||
          base_module != Object # ... or otherwise already in some namespace?
         schema_name = [(singular_schema_name = base_name.underscore),
                        (schema_name = singular_schema_name.pluralize),
@@ -1141,7 +1165,6 @@ class Object
       singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
 
       if base_model
-        schema_name = base_name.underscore # For the auto-STI namespace models
         table_name = base_model.table_name
         build_model_worker(base_module, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
       else
@@ -1171,7 +1194,7 @@ class Object
       full_name = if relation || schema_name.blank?
                     inheritable_name || model_name
                   else # Prefix the schema to the table name + prefix the schema namespace to the class name
-                    schema_module = if schema_name.instance_of?(Module) # from an auto-STI namespace?
+                    schema_module = if schema_name.is_a?(Module) # from an auto-STI namespace?
                                       schema_name
                                     else
                                       matching = "#{schema_name}.#{matching}"
@@ -1870,7 +1893,7 @@ class Object
                   upd_hash['invitation_accepted_at'] = nil if upd_hash['invitation_accepted_at'].blank?
                 end
               end
-              if (json_cols = model.columns.select { |c| c.type == :json || json_overrides&.include?(c.name) }.map(&:name)).present?
+              if (json_cols = model.columns.select { |c| model.json_column?(c) }.map(&:name)).present?
                 upd_hash ||= upd_params.to_h
                 json_cols.each do |c|
                   begin
@@ -2498,9 +2521,9 @@ module Brick
   # rubocop:enable Style/CommentedKeyword
 
   class << self
-    def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
+    def _add_bt_and_hm(fk, relations, polymorphic_class = nil, is_optional = false)
       bt_assoc_name = ::Brick.namify(fk[2], :downcase)
-      unless is_polymorphic
+      unless polymorphic_class
         bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
                           bt_assoc_name[-3] == '_' ? bt_assoc_name[0..-4] : bt_assoc_name[0..-3]
                         elsif bt_assoc_name.downcase.end_with?('id') && bt_assoc_name.exclude?('_')
@@ -2555,7 +2578,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[1]][:cols]).key?(fk[2]) || (is_polymorphic && cols.key?("#{fk[2]}_id") && cols.key?("#{fk[2]}_type"))
+        unless (cols = relations[fk[1]][:cols]).key?(fk[2]) || (polymorphic_class && cols.key?("#{fk[2]}_id") && cols.key?("#{fk[2]}_type"))
           columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[2]}. (Columns present in #{fk[1]} are #{columns.join(', ')}.)"
           return
@@ -2572,9 +2595,10 @@ module Brick
       return unless bts # Rails 5.0 and older can have bts end up being nil
 
       if (assoc_bt = bts[cnstr_name])
-        if is_polymorphic
+        if polymorphic_class
           # Assuming same fk (don't yet support composite keys for polymorphics)
           assoc_bt[:inverse_table] << fk[4]
+          assoc_bt[:polymorphic] << polymorphic_class
         else # Expect we could have a composite key going
           if assoc_bt[:fk].is_a?(String)
             assoc_bt[:fk] = [assoc_bt[:fk], fk[2]] unless fk[2] == assoc_bt[:fk]
@@ -2584,10 +2608,10 @@ module Brick
           assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[2]}"
         end
       else
-        inverse_table = [primary_table] if is_polymorphic
+        inverse_table = [primary_table] if polymorphic_class
         assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[2], assoc_name: bt_assoc_name, inverse_table: inverse_table || primary_table }
         assoc_bt[:optional] = true if is_optional
-        assoc_bt[:polymorphic] = true if is_polymorphic
+        assoc_bt[:polymorphic] = [polymorphic_class] if polymorphic_class
       end
       if is_class
         # For use in finding the proper :source for a HMT association that references an STI subclass
@@ -2613,7 +2637,7 @@ module Brick
                   end
         assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: fk_namified.pluralize, alternate_name: bt_assoc_name,
                                           inverse_table: inv_tbl, inverse: assoc_bt }
-        assoc_hm[:polymorphic] = true if is_polymorphic
+        assoc_hm[:polymorphic] = true if polymorphic_class
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         this_hm_count = hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
       end
@@ -2671,11 +2695,13 @@ module Brick
                    end
                  end
                end
-      ::Brick.relations.keys.map do |v|
-        tbl_parts = v.split('.')
+      ::Brick.relations.map do |k, v|
+        tbl_parts = k.split('.')
         tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
         res = tbl_parts.join('.')
-        [v, (model = models[res])&.last&.table_name, migrations&.fetch(res, nil), model&.first]
+        [k, (model = models[res])&.last&.table_name || v[:class_name].constantize.table_name,
+            migrations&.fetch(res, nil),
+            model&.first]
       end
     end
 

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

@@ -1245,6 +1245,7 @@ erDiagram
   }
 <% end
  # callback < %= cb_k % > erdClick
+ @_brick_monetized_attributes = model.respond_to?(:monetized_attributes) ? model.monetized_attributes.values : {}
  %>
 </div>
 "
@@ -1612,7 +1613,7 @@ end
    end %>
 </table>
 <%
-if (description = (relation = Brick.relations[tbl_name = #{model_name}.table_name])&.fetch(:description, nil)) %><%=
+if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
   description %><br><%
 end
 %><%= link_to \"(See all #\{model_name.pluralize})\", see_all_path %>
@@ -1686,22 +1687,25 @@ end
          elsif val
            \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
          end %>
-    <% else
-         col_type = if ::Brick.config.json_columns[tbl_name]&.include?(k)
-                     :json
-                   elsif col&.sql_type == 'geography'
-                     col.sql_type
-                   else
-                     col&.type
-                   end
+    <% elsif @_brick_monetized_attributes&.include?(k)
+    %><%= f.text_field(k.to_sym, html_options.merge({ value: Money.new(val.to_i).format })) %><%
+       else
+         col_type = if model.json_column?(col)
+                      :json
+                    elsif col&.sql_type == 'geography'
+                      col.sql_type
+                    else
+                      col&.type
+                    end
          case (col_type ||= col&.sql_type)
          when :string, :text
            if is_bcrypt?(val) # || .readonly?
              is_revert = false %>
           <%= hide_bcrypt(val, nil, 1000) %>
         <% elsif col_type == :string
-             if model.respond_to?(:enumerized_attributes) && (opts = model.enumerized_attributes[k]&.options).present? %>
-               <%= f.select(k.to_sym, [[\"(No #\{k} chosen)\", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, html_options) %><%
+             if model.respond_to?(:enumerized_attributes) && (attr = model.enumerized_attributes[k])&.options.present?
+               enum_html_options = attr.kind_of?(Enumerize::Multiple) ? html_options.merge({ multiple: true, size: (opts = attr.options)&.length + 1 }) : html_options %>
+               <%= f.select(k.to_sym, [[\"(No #\{k} chosen)\", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, enum_html_options) %><%
              else %>
                <%= f.text_field(k.to_sym, html_options) %><%
              end

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

@@ -20,40 +20,50 @@ module Brick::Rails::FormTags
       s << col_name
       cols[col_name] = col
     end
+    composite_bts = bts.select { |k, _v| k.is_a?(Array) }
+    composite_bt_names = {}
+    composite_bt_cols = composite_bts.each_with_object([]) do |bt, s|
+      composite_bt_names[bt.first.join('__')] = bt.last
+      bt.first.each { |bt_col| s << bt_col unless s.include?(bt_col.first) }
+    end
     unless sequence # If no sequence is defined, start with all inclusions
       cust_cols = klass._br_cust_cols
       # HOT columns, kept as symbols
       hots = klass._br_bt_descrip.keys.select { |k| bts.key?(k) }
-      sequence = col_keys + cust_cols.keys + hots + hms_keys.reject { |assoc_name| inclusions&.exclude?(assoc_name) }
+      sequence = (col_keys - composite_bt_cols) +
+                 composite_bt_names.keys + cust_cols.keys + hots +
+                 hms_keys.reject { |assoc_name| inclusions&.exclude?(assoc_name) }
     end
     sequence.reject! { |nm| exclusions.include?(nm) } if exclusions
     out << sequence.each_with_object(+'') do |col_name, s|
-           if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
-             s << '<th'
-             s << " title=\"#{col.comment}\"" if col.respond_to?(:comment) && !col.comment.blank?
-             s << if (bt = bts[col_name])
-                    # Allow sorting for any BT except polymorphics
-                    "#{' x-order="' + bt.first.to_s + '"' unless bt[2]}>BT " +
+             if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
+               s << '<th '
+               s << "title=\"#{col.comment}\"" if col.respond_to?(:comment) && !col.comment.blank?
+               s << if (bt = bts[col_name])
+                      # Allow sorting for any BT except polymorphics
+                      "x-order=\"#{bt.first.to_s + '"' unless bt[2]}>BT " +
+                      bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
+                    else # Normal column
+                      "x-order=\"#{col_name + '"' if true}>#{col_name}"
+                    end
+             elsif col # HM column
+               options = {}
+               options[col[1].inheritance_column] = col[1].name unless col[1] == col[1].base_class
+               s << "<th x-order=\"#{col_name + '"' if true}>#{col[2]} "
+               s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path", options))}")
+             elsif cust_cols.key?(col_name) # Custom column
+               s << "<th x-order=\"#{col_name}\">#{col_name}"
+             elsif col_name.is_a?(Symbol) && (hot = bts[col_name]) # has_one :through
+               s << "<th x-order=\"#{hot.first.to_s}\">HOT " +
+                    hot[1].map { |hot_pair| hot_pair.first.bt_link(col_name) }.join(' ')
+             elsif (bt = composite_bt_names[col_name])
+               s << "<th x-order=\"#{bt.first.to_s + '"' unless bt[2]}>BT comp " +
                     bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
-                  else # Normal column
-                    "#{' x-order="' + col_name + '"' if true}>#{col_name}"
-                  end
-           elsif col # HM column
-             options = {}
-             options[col[1].inheritance_column] = col[1].name unless col[1] == col[1].base_class
-             s << "<th#{' x-order="' + col_name + '"' if true}>#{col[2]} "
-             s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path", options))}")
-           elsif cust_cols.key?(col_name) # Custom column
-             s << "<th x-order=\"#{col_name}\">#{col_name}"
-           elsif col_name.is_a?(Symbol) && (hot = bts[col_name]) # has_one :through
-             s << "<th x-order=\"#{hot.first.to_s}\">HOT " +
-                  hot[1].map { |hot_pair| hot_pair.first.bt_link(col_name) }.join(' ')
-             hot[1].first
-           else # Bad column name!
-             s << "<th title=\"<< Unknown column >>\">#{col_name}"
+             else # Bad column name!
+               s << "<th title=\"<< Unknown column >>\">#{col_name}"
+             end
+             s << '</th>'
            end
-           s << '</th>'
-         end
     out << "</tr></thead>
   <tbody>"
     # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
@@ -70,7 +80,7 @@ module Brick::Rails::FormTags
         out << ' class=\"dimmed\"' unless cols.key?(col_name) || (cust_col = cust_cols[col_name]) ||
                                           (col_name.is_a?(Symbol) && bts.key?(col_name)) # HOT
         out << '>'
-        if (bt = bts[col_name])
+        if (bt = bts[col_name] || composite_bt_names[col_name])
           if bt[2] # Polymorphic?
             if (poly_id = obj.send("#{bt.first}_id"))
               # Was:  obj.send("#{bt.first}_type")
@@ -119,8 +129,12 @@ module Brick::Rails::FormTags
           end
         elsif (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
           # binding.pry if col.is_a?(Array)
-          col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
-          out << display_value(col_type || col&.sql_type, val).to_s
+          out << if @_brick_monetized_attributes&.include?(col_name)
+                   val ? Money.new(val.to_i).format : ''
+                 else
+                   col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
+                   display_value(col_type || col&.sql_type, val).to_s
+                 end
         elsif cust_col
           data = cust_col.first.map { |cc_part| obj.send(cc_part.last) }
           cust_txt = klass.brick_descrip(cust_col[-2], data)
@@ -170,11 +184,8 @@ module Brick::Rails::FormTags
                        if klass
                          type_col = klass.inheritance_column # Usually 'type'
                          filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
-                         path_params = request.path_parameters.dup
-                         path_params.delete(:controller)
-                         path_params.delete(:action)
+                         path_params = request.path_parameters
                          pk = (klass.primary_key || ActiveRecord::Base.primary_key).to_sym
-                         # Used to also have this but it's a bit too permissive to identify a primary key:  (path_params.length == 1 && path_params.values.first) ||
                          if ((id = (path_params[pk] || path_params[:id] || path_params["#{klass.name.underscore}_id".to_sym])) && (obj = klass.find_by(pk => id))) ||
                             (['show', 'edit', 'update', 'destroy'].include?(action_name) && (obj = klass.first))
                            obj
@@ -183,7 +194,18 @@ module Brick::Rails::FormTags
                            # %%% If there is a polymorphic association that might relate to stuff in the path_params,
                            # try to identify an appropriate ___able_id and ___able_type filter
                            ((klass.column_names - [pk.to_s]) & path_params.keys.map(&:to_s)).each do |path_param|
-                             filter_parts << "#{path_param}=#{path_params[path_param.to_sym]}"
+                             next if [:controller, :action].include?(path_param)
+
+                             foreign_id = path_params[path_param.to_sym]
+                             # Need to convert a friendly_id slug to a real ID?
+                             if Object.const_defined?('FriendlyId') &&
+                                (assoc = klass.reflect_on_all_associations.find { |a| a.belongs_to? && a.foreign_key == path_param }) &&
+                                (assoc_klass = assoc.klass).instance_variable_get(:@friendly_id_config) &&
+                                (new_id = assoc_klass.where(assoc_klass.friendly_id_config.query_field => foreign_id)
+                                                     .pluck(assoc_klass.primary_key).first)
+                               foreign_id = new_id
+                             end
+                             filter_parts << "#{path_param}=#{foreign_id}"
                            end
                            klass
                          end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -208,7 +208,7 @@ module Brick
           if a.polymorphic?
             rel_poly_bt = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }
             if (primary_tables = rel_poly_bt&.last&.fetch(:inverse_table, [])).is_a?(Array)
-              models = primary_tables&.map { |table| table.singularize.camelize.constantize }
+              models = rel_poly_bt[1][:polymorphic]&.map { |table| table.singularize.camelize.constantize }
               s.first[a.foreign_key.to_s] = [a.name, models, true]
             else
               # This will come up when using Devise invitable when invited_by_class_name is not
@@ -218,7 +218,8 @@ module Brick
               puts "  belongs_to :#{a.name}, polymorphic: true"
             end
           else
-            s.first[a.foreign_key.to_s] = [a.name, a.klass]
+            bt_key = a.foreign_key.is_a?(Array) ? a.foreign_key : a.foreign_key.to_s
+            s.first[bt_key] = [a.name, a.klass]
           end
         else # This gets all forms of has_many and has_one
           if through # has_many :through or has_one :through
@@ -523,8 +524,13 @@ module Brick
             table_name, poly = k.split('.')
             v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").each_with_object([]) { |result, s| s << result['typ'] if result['typ'] }
             v.each do |type|
-              if relations.key?(primary_table = type.underscore.pluralize)
-                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations, true, is_optional)
+              # Allow polymorphic BT to relate to an STI subclass
+              base_type = ::Brick.config.sti_namespace_prefixes["::#{type}"] ||
+                          ::Brick.config.sti_namespace_prefixes.find { |k, _v| k.end_with?('::') && type.start_with?(k[2..-1]) }&.last&.[](2..-1)
+              if relations.key?(primary_table = (base_type || type).underscore.pluralize)
+                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations,
+                                       type, # Polymorphic class
+                                       is_optional)
               else
                 missing_stis[primary_table] = type unless ::Brick.existing_stis.key?(type)
               end
@@ -600,7 +606,8 @@ In config/initializers/brick.rb appropriate entries would look something like:
           ::Rails.configuration.eager_load_namespaces.select { |ns| ns < ::Rails::Application }.each(&:eager_load!)
         end
       else
-        Zeitwerk::Loader.eager_load_all
+        # Same as:  Zeitwerk::Loader.eager_load_all -- plus retry when something skips a beat
+        Zeitwerk::Registry.loaders.each { |loader| load_with_retry(loader) }
       end
       abstract_ar_bases = if do_ar_abstract_bases
                             ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
@@ -609,6 +616,20 @@ In config/initializers/brick.rb appropriate entries would look something like:
       abstract_ar_bases
     end
 
+    # Some classes (like Phlex::Testing::Rails) will successfully auto-load after a retry
+    def load_with_retry(loader, autoloaded = nil)
+      autoloaded ||= loader.send(:autoloaded_dirs).dup
+      begin
+        loader.eager_load
+      rescue Zeitwerk::SetupRequired
+        # This is fine -- we eager load what can be eager loaded
+      rescue Zeitwerk::NameError
+        if autoloaded != (new_auto = loader.send(:autoloaded_dirs))
+          load_with_retry(loader, new_auto.dup) # Try one more time and it could come together
+        end
+      end
+    end
+
     def display_classes(prefix, rels, max_length)
       rels.sort.each do |rel|
         ::Brick.auto_models << rel.first

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.123
+  version: 1.0.125
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-24 00:00:00.000000000 Z
+date: 2023-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord