brick 1.0.127 → 1.0.129

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a424ad95046c33fae8463661b1fb53d770e44e37b503cb68b30fce5725c5ebd
-  data.tar.gz: 2fc4b004e49497b1b15c864a646717c162e7d7d55edf6913e916fab86ebbcbb7
+  metadata.gz: 3b46bf80d393c0d6e4ffea3e8bfc1fbc03dc667902077efc9a887c8ab046a817
+  data.tar.gz: 927828e46dfd9ae6b7c14aced0f814bbc1d876e5af14aa872a13d2c13af85083
 SHA512:
-  metadata.gz: 5ebf6939ba66e746baf8c84b347630ec4e68951b23dc1efcd72bff47b3b6550c3c8d3444194489aa227a3be153b387552951fdd0fec03dc66a73306df6d6f0d4
-  data.tar.gz: e3a90e24d98d3bcb47d09e628df9958b101f8dfb9998c97307b791664e8a8b429d12febe73a1e3e322ef3aab054a9e0a103614f2053f58f1b0d2d3e580c9c083
+  metadata.gz: 49073fb48479c8df6805a35632ef321efa3144556feb1e2da701044ce110aa6cfcb8ced12186408929b8c3d6280ca6e393e886ba54eea87f0a622a58f9216e8e
+  data.tar.gz: eaccf857c54a108c764e786b5e8abd0f54ff5abbcadec558138dc947a5d7e3015fc1a5510a311301947cee815d086018e535a15958357abd3463ab59ee375908

data/lib/brick/extensions.rb

@@ -108,16 +108,16 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
-      unless build_array.is_a?(::Brick::JoinArray)
-        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)
+    def self.brick_parse_dsl(join_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
+      unless join_array.is_a?(::Brick::JoinArray)
+        join_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([join_array]) } if join_array.is_a?(::Brick::JoinHash)
+        join_array = ::Brick::JoinArray.new unless join_array.nil? || join_array.is_a?(Array)
       end
       prefix = [prefix] unless prefix.is_a?(Array)
       members = []
       unless dsl || (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
         # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
-        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
+        x = prefix.each_with_object(join_array) { |v, s| s[v.to_sym] }
         x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
         return members
       end
@@ -141,7 +141,7 @@ module ActiveRecord
             if first_parts
               if (parts = prefix + first_parts + [parts[-1]]).length > 1 && klass
                 unless is_polymorphic
-                  s = build_array
+                  s = join_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
@@ -153,7 +153,7 @@ module ActiveRecord
                   prefix << parts.shift until parts.empty?
                 end
                 # Expand this entry which refers to an association name
-                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
+                members2, dsl2a = klass.brick_parse_dsl(join_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
                 members += members2
                 dsl2 << dsl2a
                 dsl3 << dsl2a
@@ -434,7 +434,9 @@ module ActiveRecord
       @brick_links ||= { '' => table_name }
     end
 
-    def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+    def brick_select(params, selects = [], order_by = nil, translations = {},
+                     join_array = ::Brick::JoinArray.new,
+                     cust_col_override = nil)
       is_add_bts = is_add_hms = true
 
       # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
@@ -467,7 +469,7 @@ module ActiveRecord
           is_distinct = true
           distinct!
         end
-        wheres[k] = v.split(',')
+        wheres[k] = v.is_a?(String) ? v.split(',') : v
       end
 
       # %%% Skip the metadata columns
@@ -506,84 +508,90 @@ module ActiveRecord
         end
       end
 
-      if join_array.present?
-        left_outer_joins!(join_array)
-        # Touching AREL AST walks the JoinDependency tree, and in that process uses our
-        # "brick_links" patch to find how every AR chain of association names relates to exact
-        # table correlation names chosen by AREL.  We use a duplicate relation object for this
-        # because an important side-effect of referencing the AST is that the @arel instance
-        # variable gets set, and this is a signal to ActiveRecord that a relation has now
-        # become immutable.  (We aren't quite ready for our "real deal" relation object to be
-        # set in stone ... still need to add .select(), and possibly .where() and .order()
-        # things ... also if there are any HM counts then an OUTER JOIN for each of them out
-        # to a derived table to do that counting.  All of these things need to know proper
-        # table correlation names, which will now become available in brick_links on the
-        # rel_dupe object.)
-        (rel_dupe = dup).arel.ast
-
-        core_selects = selects.dup
-        id_for_tables = Hash.new { |h, k| h[k] = [] }
-        field_tbl_names = Hash.new { |h, k| h[k] = {} }
-        used_col_aliases = {} # Used to make sure there is not a name clash
-
-        # CUSTOM COLUMNS
-        # ==============
-        klass._br_cust_cols.each do |k, cc|
-          if rel_dupe.respond_to?(k) # Name already taken?
-            # %%% Use ensure_unique here in this kind of fashion:
-            # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
-            # binding.pry
-            next
-          end
+      left_outer_joins!(join_array) if join_array.present?
+
+      # If it's a CollectionProxy (which inherits from Relation) then need to dig out the
+      # core Relation object which is found in the association scope.
+      rel_dupe = (is_a?(ActiveRecord::Associations::CollectionProxy) ? scope : self).dup
+
+      # Touching AREL AST walks the JoinDependency tree, and in that process uses our
+      # "brick_links" patch to find how every AR chain of association names relates to exact
+      # table correlation names chosen by AREL.  We use a duplicate relation object for this
+      # because an important side-effect of referencing the AST is that the @arel instance
+      # variable gets set, and this is a signal to ActiveRecord that a relation has now
+      # become immutable.  (We aren't quite ready for our "real deal" relation object to be
+      # set in stone ... still need to add .select(), and possibly .where() and .order()
+      # things ... also if there are any HM counts then an OUTER JOIN for each of them out
+      # to a derived table to do that counting.  All of these things need to know proper
+      # table correlation names, which will now become available in brick_links on the
+      # rel_dupe object.)
+      rel_dupe.arel.ast
+
+      core_selects = selects.dup
+      id_for_tables = Hash.new { |h, k| h[k] = [] }
+      field_tbl_names = Hash.new { |h, k| h[k] = {} }
+      used_col_aliases = {} # Used to make sure there is not a name clash
+
+      # CUSTOM COLUMNS
+      # ==============
+      (cust_col_override || klass._br_cust_cols).each do |k, cc|
+        if rel_dupe.respond_to?(k) # Name already taken?
+          # %%% Use ensure_unique here in this kind of fashion:
+          # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+          # binding.pry
+          next
+        end
 
-          key_klass = nil
-          key_tbl_name = nil
-          dest_pk = nil
-          key_alias = nil
-          cc.first.each do |cc_part|
-            dest_klass = cc_part[0..-2].inject(klass) do |kl, cc_part_term|
-              # %%% Clear column info properly so we can do multiple subsequent requests
-              # binding.pry unless kl.reflect_on_association(cc_part_term)
-              kl.reflect_on_association(cc_part_term)&.klass || klass
-            end
-            tbl_name = rel_dupe.brick_links[cc_part[0..-2].map(&:to_s).join('.')]
-            # Deal with the conflict if there are two parts in the custom column named the same,
-            # "category.name" and "product.name" for instance will end up with aliases of "name"
-            # and "product__name".
-            if (cc_part_idx = cc_part.length - 1).zero?
-              col_alias = "br_cc_#{k}__#{table_name.tr('.', '_')}"
-            else
-              while cc_part_idx > 0 &&
-                    (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
-                    used_col_aliases.key?(col_alias)
-                cc_part_idx -= 1
-              end
-            end
-            used_col_aliases[col_alias] = nil
-            # Set up custom column links by preparing key_klass and key_alias
-            # (If there are multiple different tables referenced in the DSL, we end up creating a link to the last one)
-            if cc[2] && (dest_pk = dest_klass.primary_key)
-              key_klass = dest_klass
-              key_tbl_name = tbl_name
-              cc_part_idx = cc_part.length - 1
-              while cc_part_idx > 0 &&
-                    (key_alias = "br_cc_#{k}__#{(cc_part[cc_part_idx..-2] + [dest_pk]).map(&:to_s).join('__')}") &&
-                    key_alias != col_alias && # We break out if this key alias does exactly match the col_alias
-                    used_col_aliases.key?(key_alias)
-                cc_part_idx -= 1
-              end
+        key_klass = nil
+        key_tbl_name = nil
+        dest_pk = nil
+        key_alias = nil
+        cc.first.each do |cc_part|
+          dest_klass = cc_part[0..-2].inject(klass) do |kl, cc_part_term|
+            # %%% Clear column info properly so we can do multiple subsequent requests
+            # binding.pry unless kl.reflect_on_association(cc_part_term)
+            kl.reflect_on_association(cc_part_term)&.klass || klass
+          end
+          tbl_name = rel_dupe.brick_links[cc_part[0..-2].map(&:to_s).join('.')]
+          # Deal with the conflict if there are two parts in the custom column named the same,
+          # "category.name" and "product.name" for instance will end up with aliases of "name"
+          # and "product__name".
+          if (cc_part_idx = cc_part.length - 1).zero?
+            col_alias = "br_cc_#{k}__#{table_name.tr('.', '_')}_#{cc_part.first}"
+          else
+            while cc_part_idx > 0 &&
+                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
+                  used_col_aliases.key?(col_alias)
+              cc_part_idx -= 1
             end
-            selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
-            cc_part << col_alias
           end
-          # Add a key column unless we've already got it
-          if key_alias && !used_col_aliases.key?(key_alias)
-            selects << "#{key_tbl_name}.#{dest_pk} AS #{key_alias}"
-            used_col_aliases[key_alias] = nil
+          used_col_aliases[col_alias] = nil
+          # Set up custom column links by preparing key_klass and key_alias
+          # (If there are multiple different tables referenced in the DSL, we end up creating a link to the last one)
+          if cc[2] && (dest_pk = dest_klass.primary_key)
+            key_klass = dest_klass
+            key_tbl_name = tbl_name
+            cc_part_idx = cc_part.length - 1
+            while cc_part_idx > 0 &&
+                  (key_alias = "br_cc_#{k}__#{(cc_part[cc_part_idx..-2] + [dest_pk]).map(&:to_s).join('__')}") &&
+                  key_alias != col_alias && # We break out if this key alias does exactly match the col_alias
+                  used_col_aliases.key?(key_alias)
+              cc_part_idx -= 1
+            end
           end
-          cc[2] = key_alias ? [key_klass, key_alias] : nil
+          selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
+          cc_part << col_alias
         end
+        # Add a key column unless we've already got it
+        if key_alias && !used_col_aliases.key?(key_alias)
+          selects << "#{key_tbl_name}.#{dest_pk} AS #{key_alias}"
+          used_col_aliases[key_alias] = nil
+        end
+        cc[2] = key_alias ? [key_klass, key_alias] : nil
+      end
 
+      # LEFT OUTER JOINs
+      unless cust_col_override
         klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next unless (tbl_name = rel_dupe.brick_links[v.first.to_s]&.split('.')&.last)
@@ -644,6 +652,7 @@ module ActiveRecord
           _assoc_names[assoc_name] = [table_alias, klass]
         end
       end
+
       # Add derived table JOIN for the has_many counts
       nix = []
       klass._br_hm_counts.each do |k, hm|
@@ -781,7 +790,7 @@ module ActiveRecord
 JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
           }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
         self.joins_values |= ["#{join_clause} ON #{on_clause.join(' AND ')}"] # Same as:  joins!(...)
-      end
+      end unless cust_col_override
       while (n = nix.pop)
         klass._br_hm_counts.delete(n)
       end
@@ -851,6 +860,22 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
+    # Build out an AR relation that queries for a list of objects, and include all the appropriate JOINs to later apply DSL using #brick_descrip
+    def brick_list
+      pks = klass.primary_key.is_a?(String) ? [klass.primary_key] : klass.primary_key
+      selects = pks.each_with_object([]) { |pk, s| s << pk unless s.include?(pk) }
+      # ActiveStorage compatibility
+      selects << 'service_name' if klass.name == 'ActiveStorage::Blob' && ActiveStorage::Blob.columns_hash.key?('service_name')
+      selects << 'blob_id' if klass.name == 'ActiveStorage::Attachment' && ActiveStorage::Attachment.columns_hash.key?('blob_id')
+      pieces, my_dsl = klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
+      brick_select(
+        where_values_hash, selects, nil, translations, join_array,
+        { '_br' => (descrip_cols = [pieces, my_dsl]) }
+      )
+      order_values = klass.primary_key
+      [self.select(selects), descrip_cols]
+    end
+
   private
 
     def shift_or_first(ary)
@@ -1254,6 +1279,11 @@ class Object
           end
           self.abstract_class = true
           code << "  self.abstract_class = true\n"
+        elsif Object.const_defined?('BCrypt') && relation[:cols].include?('password_digest') &&
+              !instance_methods.include?(:password) && respond_to?(:has_secure_password)
+          puts "Appears that the #{full_name} model is intended to hold user account information.  Applying #has_secure_password."
+          has_secure_password
+          code << "  has_secure_password\n"
         end
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || table_name != matching
@@ -2718,12 +2748,17 @@ module Brick
                  end
                end
       ::Brick.relations.map do |k, v|
+        # next if Brick.config.exclude_tables.include?(k)
+
         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('.')
-        [k, (model = models[res])&.last&.table_name || v[:class_name].constantize.table_name,
-            migrations&.fetch(res, nil),
-            model&.first]
+        table_name = (model = models[res])&.last&.table_name
+        table_name ||= begin
+                         v[:class_name].constantize.table_name
+                       rescue
+                       end
+        [k, table_name || k, migrations&.fetch(res, nil), model&.first]
       end
     end
 

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

@@ -58,7 +58,7 @@ module Brick
             '(Add RGeo gem to parse geometry detail)'
           end
         when :binary
-          ::Brick::Rails.display_binary(val) if val
+          ::Brick::Rails.display_binary(val)
         else
           if col_type
             ::Brick::Rails::FormBuilder.hide_bcrypt(val, col_type == :xml)
@@ -69,8 +69,12 @@ module Brick
       end
 
       def display_binary(val)
+        return unless val
+
         @image_signatures ||= { (+"\xFF\xD8\xFF\xEE").force_encoding('ASCII-8BIT') => 'jpeg',
                                 (+"\xFF\xD8\xFF\xE0\x00\x10\x4A\x46\x49\x46\x00\x01").force_encoding('ASCII-8BIT') => 'jpeg',
+                                (+"\xFF\xD8\xFF\xDB").force_encoding('ASCII-8BIT') => 'jpeg',
+                                (+"\xFF\xD8\xFF\xE1").force_encoding('ASCII-8BIT') => 'jpeg',
                                 (+"\x89PNG\r\n\x1A\n").force_encoding('ASCII-8BIT') => 'png',
                                 '<svg' => 'svg+xml', # %%% Not yet very good detection for SVG
                                 (+'BM').force_encoding('ASCII-8BIT') => 'bmp',
@@ -90,7 +94,8 @@ module Brick
           val = val[object_start...object_start + real_object_size]
         end
 
-        if (signature = @image_signatures.find { |k, _v| val[0...k.length] == k })
+        if (signature = @image_signatures.find { |k, _v| val[0...k.length] == k }) ||
+           (val[0..3] == 'RIFF' && val[8..11] == 'WEBP' && (signature = 'webp'))
           if val.length < 500_000
             "<img src=\"data:image/#{signature.last};base64,#{Base64.encode64(val)}\">"
           else
@@ -1290,7 +1295,7 @@ erDiagram
 </head>
 <body>
 <div id=\"titleBox\"><div id=\"titleSticky\">
-<p style=\"color: green\"><%= notice %></p>#{"
+<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><tr>
@@ -1411,7 +1416,8 @@ end
     brick_grid(@#{table_name}, @_brick_bt_descrip, @_brick_sequence, @_brick_incl, @_brick_excl,
                cols, poly_cols, bts, #{hms_keys.inspect}, {#{hms_columns.join(', ')}}) %>
 
-#{"<hr><%= link_to \"New #{obj_name}\", new_#{path_obj_name}_path %>" unless @_brick_model.is_view?}
+#{"<hr><%= link_to(\"New #{new_path_name = "new_#{path_obj_name}_path"
+                           obj_name}\", #{new_path_name}) if respond_to?(:#{new_path_name}) %>" unless @_brick_model.is_view?}
 #{script}
 </body>
 </html>
@@ -1423,7 +1429,7 @@ end
 # Must load all models, and then find what table names are represented
 # Easily could be multiple files involved (STI for instance)
 +"#{css}
-<p style=\"color: green\"><%= notice %></p>#{"
+<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Status</h1>
@@ -1473,7 +1479,7 @@ end
                        when 'orphans'
                          if is_orphans
 +"#{css}
-<p style=\"color: green\"><%= notice %></p>#{"
+<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Orphans<%= \" for #\{}\" if false %></h1>
@@ -1520,7 +1526,7 @@ end
   c23.141-70.188,89.141-120.906,167.063-120.906c97.25,0,176,78.813,176,176C511.828,227.078,404.391,119.641,271.844,119.641z\" />
 </svg>
 
-<p style=\"color: green\"><%= notice %></p>#{"
+<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <table><td><h1><%= page_title %></h1></td>
@@ -1555,14 +1561,13 @@ end
 %><%= link_to \"(See all #\{model_name.pluralize})\", see_all_path %>
 #{erd_markup}
 <% if obj
-      # path_options = [obj.#{pk}]
-      # path_options << { '_brick_schema':  } if
-      # url = send(:#\{model._brick_index(:singular)}_path, obj.#{pk})
-      options = {}
-      if ::Brick.config.path_prefix
-        path_helper = obj.new_record? ? #{model_name}._brick_index : #{model_name}._brick_index(:singular)
-        options[:url] = send(\"#\{path_helper}_path\".to_sym, obj)
-      end
+     # path_options = [obj.#{pk}]
+     # path_options << { '_brick_schema':  } if
+     options = {}
+     if ::Brick.config.path_prefix
+       path_helper = obj.new_record? ? #{model_name}._brick_index : #{model_name}._brick_index(:singular)
+       options[:url] = send(\"#\{path_helper}_path\".to_sym, obj)
+     end
 %>
   <br><br>
 <%= form_for(obj.becomes(#{model_name}), options) do |f| %>
@@ -1570,11 +1575,11 @@ end
   <% has_fields = false
      @#{obj_name}.attributes.each do |k, val|
        next if !(col = #{model_name}.columns_hash[k]) ||
-               (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
+               (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
                ::Brick.config.metadata_columns.include?(k) %>
     <tr>
     <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
-    <% has_fields = true
+<%    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('/')
@@ -1602,7 +1607,15 @@ end
         if bt.length < 4
           bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
           # %%% Accommodate composite keys for obj.pk at the end here
-          bt_class&.order(obj_pk = bt_class.primary_key)&.each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
+          collection, descrip_cols = bt_class&.order(obj_pk = bt_class.primary_key).brick_list
+          collection&.each do |obj|
+            option_detail << [
+              obj.brick_descrip(
+                descrip_cols&.first&.map { |col| obj.send(col.last) },
+                obj_pk
+              ), obj.send(obj_pk)
+            ]
+          end
         end %>
         BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
     <% else %>
@@ -1619,7 +1632,11 @@ end
   <% else %>
     <tr><td colspan=\"2\">(No displayable fields)</td></tr>
   <% end %>
-  </table>
+  </table>#{
+  "<%= binary = begin
+                  ::Brick::Rails.display_binary(obj&.blob&.download)&.html_safe
+                rescue
+                end %>" if model_name == 'ActiveStorage::Attachment'}
 <%  end %>
 
 #{unless args.first == 'new'
@@ -1634,34 +1651,51 @@ end
       obj_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "#{hm_singular_name}.#{pk_part}" }.join(', ')
       poly_fix = if (poly_type = (hm.first.options[:as] && hm.first.type))
                    "
-                       # Let's fix an unexpected \"feature\" of AR -- when going through a polymorphic has_many
-                       # association that points to an STI model then filtering for the __able_type column is done
-                       # with a .where(). And the polymorphic class name it points to is the base class name of
-                       # the STI model instead of its subclass.
-                       poly_type = #{poly_type.inspect}
-#{                     (inh_col = @_brick_model.inheritance_column).present? &&
-"                      if poly_type && @#{obj_name}.respond_to?(:#{inh_col}) &&
-                          (base_type = collection.where_values_hash[poly_type])
-                         collection = collection.rewhere(poly_type => [base_type, @#{obj_name}.#{inh_col}])
-                       end"}"
+                     # Let's fix an unexpected \"feature\" of AR -- when going through a polymorphic has_many
+                     # association that points to an STI model then filtering for the __able_type column is done
+                     # with a .where(). And the polymorphic class name it points to is the base class name of
+                     # the STI model instead of its subclass.
+                     poly_type = #{poly_type.inspect}
+#{                   (inh_col = @_brick_model.inheritance_column).present? &&
+"                    if poly_type && @#{obj_name}.respond_to?(:#{inh_col}) &&
+                        (base_type = collection.where_values_hash[poly_type])
+                       collection = collection.rewhere(poly_type => [base_type, @#{obj_name}.#{inh_col}])
+                     end"}"
                  end
       s << "<table id=\"#{hm_name}\" class=\"shadow\">
         <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}</th></tr>
-        <% collection = @#{obj_name}.#{hm_name}
-        collection = case collection
-                     when ActiveRecord::Associations::CollectionProxy#{
-                       poly_fix}
-                       collection.order(#{pk.inspect})
-                     when ActiveRecord::Base # Object from a has_one
-                       [collection]
-                     else # We get an array back when AR < 4.2
-                       collection.to_a.compact
-                     end
-        if collection.empty? %>
+        <% if (assoc = @#{obj_name}.class.reflect_on_association(:#{hm_name})).macro == :has_one &&
+              assoc.options&.fetch(:through, nil).nil?
+             # In order to apply DSL properly, evaluate this HO the other way around as if it were as a BT
+             collection = assoc.klass.where(assoc.foreign_key => @#{obj_name}.#{pk})
+             collection = collection.instance_exec(&assoc.scopes.first) if assoc.scopes.present?
+             if assoc.klass.name == 'ActiveStorage::Attachment'
+               br_descrip = begin
+                              ::Brick::Rails.display_binary(obj.send(assoc.name)&.blob&.download)&.html_safe
+                            rescue
+                            end
+             end
+           else
+             collection = @#{obj_name}.#{hm_name}
+           end
+        case collection
+        when ActiveRecord::Relation # has_many (which comes in as a CollectionProxy) or a has_one#{
+          poly_fix}
+          collection2, descrip_cols = collection.brick_list
+        when ActiveRecord::Base # Object from a has_one :through
+          collection2 = [collection]
+        else # We get an array back when AR < 4.2
+          collection2 = collection.to_a.compact
+        end
+        collection2 = collection2.uniq
+        if collection2.empty? %>
           <tr><td>(none)</td></tr>
-        <% else %>
-          <% collection.uniq.each do |#{hm_singular_name}| %>
-            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
+     <% else
+          collection2.each do |#{hm_singular_name}| %>
+            <tr><td><%= br_descrip ||= #{hm_singular_name}.brick_descrip(
+                                         descrip_cols&.first&.map { |col| #{hm_singular_name}.send(col.last) }
+                                       )
+                        link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
           <% end %>
         <% end %>
       </table>"

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

@@ -115,7 +115,14 @@ module Brick::Rails::FormTags
             if col[2] == 'HO'
               descrips = bt_descrip[col_name.to_sym][hm_klass]
               if (ho_id = (ho_id_col = descrips.last).map { |id_col| obj.send(id_col.to_sym) })&.first
-                ho_txt = hm_klass.brick_descrip(obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, ho_id_col)
+                ho_txt = if hm_klass.name == 'ActiveStorage::Attachment'
+                           begin
+                             ::Brick::Rails.display_binary(obj.send(col[3])&.blob&.download)&.html_safe
+                           rescue
+                           end
+                         else
+                           hm_klass.brick_descrip(obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, ho_id_col)
+                         end
                 out << link_to(ho_txt, send("#{hm_klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
               end
             else

data/lib/brick/version_number.rb

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

metadata

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