brick 1.0.123 → 1.0.124

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baad039242ee5623097ad6170fec07e5feb0eb2fed6d41a9079f0775cccaceea
-  data.tar.gz: 603377f6b2c4437c448630bce6581d3650b8dfc13187e82afbaab1d425d171e2
+  metadata.gz: 44fce70a53b4467d019ca42a9826f44a4849d472dcbfc2fe324f961708b70a18
+  data.tar.gz: 2674709f203786560b41c1bf1e2062336cf88282d168848303e9920b398662e3
 SHA512:
-  metadata.gz: 1f4e48c1a437684929a81ace3e75ab15bb627c006680dba5a7454825fba358142560712f016bf944575aefeb27655716c3212d72a2b9b5a083a09cd2dfa8537c
-  data.tar.gz: ea9c376866230e4c2bab7b6c34dfc435a8cf81b568bc22af3a0e69497accca1620152ae311eab6c96649b79ecedf978b880afa88888dc6d1c4d3700bc3ef3060
+  metadata.gz: 337760a0382fd37a64026a07d80e708f9f475f73e8ca420d05341b731c977ab9153556803f10314a4851730e28a22ce4847705e2d8ad81121a8f33736f505f12
+  data.tar.gz: 04a1e5ec1cc503173da16be708d611f9fb1dd6f3965e6e848dfd1e310f3e1c94b396c8e693982d8f3c3589b5d8ffbfee70fd52593918e12ecd8309c8e110b4c5

data/lib/brick/extensions.rb

@@ -638,6 +638,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,6 +669,8 @@ module ActiveRecord
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             link_back << nm
+                                            num_bt_things += 1
+                                            # puts "BT #{a.table_name}"
                                             "ON br_t#{idx}.id = 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"
@@ -686,6 +689,7 @@ module ActiveRecord
                                                 "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.id"
                                             end
                                           else # Standard has_many or has_one
+                                            # puts "HM #{a.table_name}"
                                             # binding.pry unless (
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             # )
@@ -708,7 +712,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
@@ -2498,9 +2508,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 +2565,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 +2582,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 +2595,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 +2624,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

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

@@ -170,11 +170,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 +180,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 = 124
 
     # 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
@@ -523,8 +523,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| 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

metadata

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