brick 1.0.21 → 1.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ad289d9f4db9ef6ce9edcfb8948926d4a61910294291272ccf2b342fa2f5051
-  data.tar.gz: 9030f9ccf39d7f0a9a0ff9413e4f24ee7a46beaf3aba056e9875fc5c29551419
+  metadata.gz: 82ebef3561b9cd7b8abcbbd8a30b7687485543ddf1a0900a9935dfb99299f13f
+  data.tar.gz: ba071d53409fd8d4833693907364c745585aeb0bb18e885fcf7cbf1bd23b9940
 SHA512:
-  metadata.gz: ed6f08eabba91cb304141a0c84884cfbeaae0087094b1fe1ff4a80195aee44dbb697c385ab9d7afaac2e337f9008bc7bef059be98f95264fec34a2288beaff6b
-  data.tar.gz: 5ebbb793d23634232a529b3d39224e1e4deaa010cf8bf2841effe20a9e3b4d7079fb7163e6c2f90feeed8526c4a1314f319bad47d1c8a6079bf54ca92f0e6224
+  metadata.gz: 69ad3ae158a8e478864db65dc808152d4b1b16bdc8779b1a651f59f199167daf00d2aa10018c5f65d5e619bbca4c09e99bc319ca736eed57023d61e6067ea365
+  data.tar.gz: 18ca63e176e12ea50a5168e835a2eddfa66c8f522943d42e6d895d2f3e05d0cf6d396ab28d79f98898c91670b618cc27dbad5fa0bc9129a3edcfc3f74f5db029

data/lib/brick/extensions.rb

@@ -166,8 +166,8 @@ module ActiveRecord
       if is_brackets_have_content
         output
       elsif pk_alias
-        if (id = obj.send(pk_alias))
-          "#{klass.name} ##{id}"
+        if (id = pk_alias.map { |pk_alias_part| obj.send(pk_alias_part) })
+          "#{klass.name} ##{id.join(', ')}"
         end
       # elsif klass.primary_key
       #   "#{klass.name} ##{obj.send(klass.primary_key)}"
@@ -176,6 +176,14 @@ module ActiveRecord
       end
     end
 
+    def self.bt_link(assoc_name)
+      model_underscore = name.underscore
+      assoc_name = CGI.escapeHTML(assoc_name.to_s)
+      model_path = Rails.application.routes.url_helpers.send("#{model_underscore.pluralize}_path".to_sym)
+      link = Class.new.extend(ActionView::Helpers::UrlHelper).link_to(name, model_path)
+      model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+    end
+
   private
 
     def self._brick_get_fks
@@ -267,27 +275,6 @@ module ActiveRecord
       # , is_add_bts, is_add_hms
     )
       is_add_bts = is_add_hms = true
-      wheres = {}
-      has_hm = false
-      params.each do |k, v|
-        case (ks = k.split('.')).length
-        when 1
-          next unless klass._brick_get_fks.include?(k)
-        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 (assoc = klass.reflect_on_association(assoc_name))&.klass&.columns&.map(&:name)&.include?(ks.last)
-
-          # So that we can map an association name to any special alias name used in an AREL query
-          ans = (assoc.klass._assoc_names[assoc_name] ||= [])
-          ans << assoc.klass unless ans.include?(assoc.klass)
-          # There is some potential for duplicates when there is an HM-based where in play.  De-duplicate if so.
-          has_hm ||= assoc.macro == :has_many
-          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
-        end
-        wheres[k] = v.split(',')
-      end
-      # distinct! if has_hm
 
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
@@ -301,59 +288,101 @@ module ActiveRecord
       if is_add_bts || is_add_hms
         bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
         bts.each do |_k, bt|
-          # join_array[bt.first] = nil # Store this relation name in our special collection for .joins()
+          # 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)]
         end
         skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
         hms.each do |k, hm|
           next if skip_klass_hms.key?(k)
 
-          join_array[k] = nil # Store this relation name in our special collection for .joins()
-          hm_counts[k] = nil # Placeholder that will be filled in once we know the proper table alias
+          hm_counts[k] = hm
         end
       end
-      where!(wheres) unless wheres.empty?
+
+      wheres = {}
+      params.each do |k, v|
+        case (ks = k.split('.')).length
+        when 1
+          next unless klass._brick_get_fks.include?(k)
+        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 }
+
+          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
+        end
+        wheres[k] = v.split(',')
+      end
+
       if join_array.present?
         left_outer_joins!(join_array) # joins!(join_array)
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
         (rel_dupe = dup)._arel_alias_names
         core_selects = selects.dup
-        groups = []
         chains = rel_dupe._brick_chains
-        id_for_tables = {}
+        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 = chains[v.last.first].first
-          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(tbl_name)
-            groups << (unaliased = "#{tbl_name}.#{id_col}")
-            selects << "#{unaliased} AS \"#{(id_alias = id_for_tables[tbl_name] = "_brfk_#{v.first}__#{id_col}")}\""
-            v.last << id_alias
+          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)
+            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|
-              groups << (unaliased = "#{tbl_name = chains[sel_col.first].first}.#{sel_col.last}")
+              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
-              tbl_name2 = tbl_name.start_with?('public.') ? tbl_name[7..-1] : tbl_name
-              selects << "#{unaliased} AS \"#{(col_alias = "_brfk_#{tbl_name2}__#{sel_col.last}")}\""
+              selects << "#{"#{field_tbl_name}.#{sel_col.last}"} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
               v.last[1][idx] << col_alias
             end
           end
         end
-        group!(core_selects + groups) if hm_counts.any? #  + bt_columns
         join_array.each do |assoc_name|
           # %%% Need to support {user: :profile}
           next unless assoc_name.is_a?(Symbol)
 
-          klass = reflect_on_association(assoc_name)&.klass
-          table_alias = chains[klass].length > 1 ? chains[klass].shift : chains[klass].first
+          table_alias = shift_or_first(chains[klass = reflect_on_association(assoc_name)&.klass])
           _assoc_names[assoc_name] = [table_alias, klass]
         end
-        # Copy entries over
-        hm_counts.keys.each do |k|
-          hm_counts[k] = _assoc_names[k]
+      end
+      # Add derived table JOIN for the has_many counts
+      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
+        tbl_alias = "_br_#{hm.name}"
+        pri_tbl = hm.active_record
+        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 ')}")
+        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}")
         end
       end
+      where!(wheres) unless wheres.empty?
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
+
+  private
+
+    def shift_or_first(ary)
+      ary.length > 1 ? ary.shift : ary.first
+    end
   end
 
   module Inheritance
@@ -552,27 +581,30 @@ class Object
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
           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
-            assoc_name = (assoc = fk.last)[:assoc_name]
-            inverse_assoc_name = assoc[:inverse]&.fetch(:assoc_name, nil)
+            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
-                      if (primary_class = assoc.fetch(:primary_class, nil)) &&
-                         (sti_inverse_assoc = primary_class.reflect_on_all_associations.find { |a| a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key })
-                        assoc_name = sti_inverse_assoc.options[:inverse_of].to_s || assoc_name
-                      end
+                      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
+                                                 need_inverse_of = true
+                                                 has_ones[singular_inv_assoc_name]
+                                               else
+                                                 singular_inv_assoc_name
+                                               end
                         end
                       end
                       :belongs_to
@@ -583,12 +615,12 @@ class Object
                       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 has_ones[singular_assoc_name]
-                                      need_class_name = true
-                                      has_ones[singular_assoc_name]
-                                    else
-                                      singular_assoc_name
-                                    end
+                        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
@@ -674,7 +706,7 @@ class Object
           @_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?
-          counts = hm_counts.each_with_object([]) { |v, s| s << "COUNT(DISTINCT #{v.last.first}.#{v.last.last.primary_key}) AS _br_#{v.first}_ct" }
+          counts = hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
           # *selects, 
           instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
           # binding.pry
@@ -732,7 +764,8 @@ class Object
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
       if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
-        [ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name]), true]
+        plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
+        [hm_assoc[:alternate_name] == name.underscore ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural, true]
       else
         [ActiveSupport::Inflector.pluralize(hm_assoc[:inverse_table]), nil]
       end
@@ -989,18 +1022,16 @@ module Brick
 
       return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
 
-      cnstr_name = "hm_#{cnstr_name}"
-      if (assoc_hm = hms.fetch(cnstr_name, nil))
+      if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
         assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
         assoc_hm[:inverse] = assoc_bt
       else
-        assoc_hm = hms[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 = 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 }
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
       end
       assoc_bt[:inverse] = assoc_hm
-      # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
     end
   end
 end

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

@@ -64,6 +64,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(', ')
+            end
+
             alias :_brick_find_template :find_template
             def find_template(*args, **options)
               return  _brick_find_template(*args, **options) unless @_brick_model
@@ -73,35 +81,32 @@ module Brick
               obj_name = model_name.underscore
               table_name = model_name.pluralize.underscore
               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'
+              hms_columns = [] # Used for 'index'
               skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
               hms_headers = hms.each_with_object([]) do |hm, s|
-                hm_assoc = hm.last
-                if args.first == 'index'
-                  hm_fk_name = if hm_assoc.options[:through]
-                                 associative = associatives[hm_assoc.name]
-                                 "'#{associative.name}.#{associative.foreign_key}'"
-                               else
-                                 hm_assoc.foreign_key
-                               end
-                  hms_columns << if hm_assoc.macro == :has_many
-                    set_ct = if skip_klass_hms.key?((assoc_name = hm.first).to_sym)
-                               'nil'
+                hm_stuff = [(hm_assoc = hm.last), "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}", (assoc_name = hm.first)]
+                hm_fk_name = if hm_assoc.options[:through]
+                               associative = associatives[hm_assoc.name]
+                               "'#{associative.name}.#{associative.foreign_key}'"
                              else
-                               "#{obj_name}._br_#{assoc_name}_ct"
+                               hm_assoc.foreign_key
                              end
-
-"<td>
-  <%= ct = #{set_ct}
-      link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless ct&.zero? %>
-</td>\n"
+                if args.first == 'index'
+                  hms_columns << if hm_assoc.macro == :has_many
+                                   set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
+                                              'nil'
+                                            else
+                                              "#{obj_name}._br_#{assoc_name}_ct || 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"
                                  else # has_one
-"<td>
-  <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
-</td>\n"
+"<%= 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"
                 end
-                s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
+                s << hm_stuff
               end
 
               schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
@@ -121,9 +126,12 @@ table {
 
 table thead tr th, table tr th {
   background-color: #009879;
-  color: #ffffff;
+  color: #fff;
   text-align: left;
 }
+table thead tr th a, table tr th a {
+  color: #80FFB8;
+}
 
 table th, table td {
   padding: 0.2em 0.5em;
@@ -132,6 +140,9 @@ table th, table td {
 .show-field {
   background-color: #004998;
 }
+.show-field a {
+  color: #80B8D2;
+}
 
 table tbody tr {
   border-bottom: thin solid #dddddd;
@@ -244,6 +255,11 @@ function changeout(href, param, value) {
 </script>"
               inline = case args.first
                        when 'index'
+                         obj_pk = if pk&.is_a?(Array) # Composite primary key?
+                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]"
+                                  elsif pk
+                                    "#{obj_name}.#{pk}"
+                                  end
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
@@ -256,26 +272,27 @@ function changeout(href, param, value) {
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
-      BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
+      BT <%= bt[1].bt_link(bt.first) %>
     <% else %>
       <%= col %>
     <% end %>
     </th>
   <% end %>
-  #{hms_headers.map { |h| "<th>#{h.last}</th>\n" }.join}
+  <%# Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name %>
+  #{hms_headers.map { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.pluralize}_path) %></th>\n" }.join}
   </tr></thead>
 
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk}
+    <td><%= link_to '⇛', #{obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if 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')) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%# binding.pry if bt.first == :user %>
-        <% bt_txt = bt[1].brick_descrip(#{obj_name}, @_brick_bt_descrip[bt.first][1].map { |z| #{obj_name}.send(z.last) }, @_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 %>
+        <%# 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 %>
       <% else %>
@@ -283,7 +300,7 @@ function changeout(href, param, value) {
       <% end %>
       </td>
     <% end %>
-#{hms_columns}
+    <td>#{hms_columns.join('</td><td>')}</td>
     <!-- td>X</td -->
   </tr>
   </tbody>
@@ -301,9 +318,9 @@ 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 
+   # path_options << { '_brick_schema':  } if
    # url = send(:#{model_name.underscore}_path, obj.#{pk})
-   form_for(obj) do |f| %>
+   form_for(obj.becomes(#{model_name})) do |f| %>
   <table>
   <% @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
@@ -317,7 +334,7 @@ function changeout(href, param, value) {
         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.first\}-\" unless bt_name.underscore == bt.first.to_s %><%= bt_name %>
+      BT <%= bt[1].bt_link(bt.first) %>
     <% else %>
       <%= k %>
     <% end %>
@@ -353,21 +370,24 @@ function changeout(href, param, value) {
   </table>
   <% end %>
 
-  #{hms_headers.map do |hm|
-    next unless (pk = hm.first.klass.primary_key)
-
-  "<table id=\"#{hm_name = hm.first.name.to_s}\">
-    <tr><th>#{hm.last}</th></tr>
-    <% collection = @#{obj_name}.first.#{hm_name}
-    collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
-    if collection.empty? %>
-      <tr><td>(none)</td></tr>
-    <% else %>
-      <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
-        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
-      <% end %>
-    <% end %>
-  </table>" end.join}
+  #{hms_headers.each_with_object(+'') do |hm, s|
+    if (pk = hm.first.klass.primary_key)
+      s << "<table id=\"#{hm_name = hm.first.name.to_s}\">
+        <tr><th>#{hm[3]}</th></tr>
+        <% collection = @#{obj_name}.first.#{hm_name}
+        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
+        if collection.empty? %>
+          <tr><td>(none)</td></tr>
+        <% else %>
+          <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
+          <% end %>
+        <% end %>
+      </table>"
+    else
+      s
+    end
+  end}
 <% end %>
 #{script}"
 

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -105,9 +105,6 @@ module Brick
       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)
 
-        # So that we can map an association name to any special alias name used in an AREL query
-        ans = (model._assoc_names[a.name] ||= [])
-        ans << a.klass unless ans.include?(a.klass)
         case a.macro
         when :belongs_to
           s.first[a.foreign_key] = [a.name, a.klass]
@@ -427,9 +424,7 @@ ActiveSupport.on_load(:active_record) do
               end
 
               result = result.map do |attributes|
-                values = klass.initialize_attributes(attributes).values
-
-                columns.zip(values).map do |column, value|
+                columns.zip(klass.initialize_attributes(attributes).values).map do |column, value|
                   column.type_cast(value)
                 end
               end

metadata

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