brick 1.0.97 → 1.0.98

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c257a0a65807fa87a13d722f3cc30c38d51bde571a070df53f4277fc6db8b7ba
-  data.tar.gz: 74d7690a968fab671d9e9e8ac92e41885ceb44a700fd1cb293f3b79af819e463
+  metadata.gz: d4285ef6fb81d75bd90ceffc7d66c7fa096f04fb998da590f291f28fc9dfb45d
+  data.tar.gz: 2d031b156fd9c82d19af9b7818387eaecdd8cfadf939cbcf3b3b479474a77b54
 SHA512:
-  metadata.gz: 4337faa80a6f0d9c1dadcb3271aea14ec54bb91e72cd7eead7e59c860557f828ac073cab3768feaa2db2f664d63b1604bd8f8e0d53c64621b1fcf5cc041057d9
-  data.tar.gz: 541cade2070bd0a79b21dd7155df700b2739084ae81eaa02709f9e00164f956e62e8342330a78496c4b5fbf351cac9ea40483d3cdc32c1fb1dbe8d7e34499d2d
+  metadata.gz: 5967ede119f86cd92f88abb0f43bd2049eda4272c14ae7fa1c3f9ecc54c813c4c227be2d99aaa501363e42ef34a3eb5d0a0924ac4e540ab668e40a9a9d28311e
+  data.tar.gz: ab01005e485b9335c67ba48bb01a13db78fed3ce31293122fae8fbf1317b3bc0c3197adb087ec4b125e2ff7153e52fb55d8b7fc675b1e7759233cf8d42769ac7

data/lib/brick/extensions.rb

@@ -540,7 +540,11 @@ module ActiveRecord
             tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(tbl_name)
             field_tbl_name = nil
             v1.map { |x| [x[0..-2].map(&:to_s).join('.'), x.last] }.each_with_index do |sel_col, idx|
-              field_tbl_name = rel_dupe.brick_links[sel_col.first].split('.').last
+              # %%% Strangely in Rails 7.1 on a slower system then very rarely brick_link comes back nil...
+              brick_link = rel_dupe.brick_links[sel_col.first]
+              field_tbl_name = brick_link&.split('.')&.last ||
+                # ... so here's a best-effort guess for what the table name might be.
+                rel_dupe.klass.reflect_on_association(sel_col.first).klass.table_name
               # If it's Oracle, quote any AREL aliases that had been applied
               field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(field_tbl_name)
 
@@ -825,80 +829,9 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
 end
 
 if Object.const_defined?('ActionView')
+  require 'brick/frameworks/rails/form_tags'
   module ActionView::Helpers::FormTagHelper
-    def link_to_brick(*args, **kwargs)
-      return unless ::Brick.config.mode == :on
-
-      text = (args.first.is_a?(String) && args.first) || args[1]
-      klass_or_obj = ((args.first.is_a?(ActiveRecord::Relation) ||
-                       args.first.is_a?(ActiveRecord::Base) ||
-                       args.first.is_a?(Class)) &&
-                      args.first) ||
-                     @_brick_model
-      # If not provided, do a best-effort to automatically determine the resource class or object
-      filter_parts = []
-      klass_or_obj ||= begin
-                         klass, sti_type = ::Brick.ctrl_to_klass(controller_path)
-                         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)
-                           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
-                           else
-                             # %%% If there is a HMT that refers to some ___id then try to identify an appropriate filter
-                             # %%% 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]}"
-                             end
-                             klass
-                           end
-                         end
-                       rescue
-                       end
-      if klass_or_obj
-        if klass_or_obj.is_a?(ActiveRecord::Relation)
-          klass_or_obj.where_values_hash.each do |whr|
-            filter_parts << "#{whr.first}=#{whr.last}" if whr.last && !whr.last.is_a?(Array)
-          end
-          klass_or_obj = klass_or_obj.klass
-          type_col = klass_or_obj.inheritance_column
-          if klass_or_obj.column_names.include?(type_col) && klass_or_obj.name != klass_or_obj.base_class.name
-            filter_parts << "#{type_col}=#{klass_or_obj.name}"
-          end
-        elsif klass_or_obj.is_a?(ActiveRecord::Base) && klass_or_obj.new_record?
-          klass_or_obj = klass_or_obj.class
-        end
-        filter = "?#{filter_parts.join('&')}" if filter_parts.present?
-        if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
-           (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
-          lt_args = [text || "Index for #{klass_or_obj.name.pluralize}",
-                    "#{send("#{klass_or_obj._brick_index}_path")}#{filter}"]
-        else
-          # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
-          lt_args = [text || "Show this #{klass_or_obj.class.name}",
-                    "#{send("#{klass_or_obj.class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"]
-        end
-        link_to(*lt_args, **kwargs)
-      else
-        # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
-        # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
-        links = instance_variables.each_with_object([]) do |name, s|
-                  iv_name = name.to_s[1..-1]
-                  case (val = instance_variable_get(name))
-                  when ActiveRecord::Relation, ActiveRecord::Base
-                    s << link_to_brick(val, iv_name) if val
-                  end
-                end
-        links.join(' &nbsp; ').html_safe
-      end
-    end
+    include ::Brick::Rails::FormTags
   end
 end
 
@@ -1002,6 +935,7 @@ Module.class_exec do
     end
     class_name = ::Brick.namify(requested)
     relations = ::Brick.relations
+    #        CONTROLLER
     result = if ::Brick.enable_controllers? &&
                 is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
@@ -1020,6 +954,8 @@ Module.class_exec do
                  # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
+
+             # MODULE
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
                    base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
                    (schema_name = [(singular_table_name = class_name.underscore),
@@ -1036,6 +972,50 @@ Module.class_exec do
 
                [built_module, "module #{schema_name}; end\n"]
                #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
+
+             # AVO Resource
+             elsif base_module == Object && Object.const_defined?('Avo') && requested.end_with?('Resource') &&
+                   ['MotorResource'].exclude?(requested) # Expect that anything called MotorResource could be from that administrative gem
+               if (model = Object.const_get(requested[0..-9]))
+                 require 'generators/avo/resource_generator'
+                 field_generator = Generators::Avo::ResourceGenerator.new([''])
+                 field_generator.instance_variable_set(:@model, model)
+                 fields = field_generator.send(:generate_fields).split("\n")
+                                         .each_with_object([]) do |f, s|
+                                           if (f = f.strip).start_with?('field ')
+                                             f = f[6..-1].split(',')
+                                             s << [f.first[1..-1].to_sym, [f[1][1..-1].split(': :').map(&:to_sym)].to_h]
+                                           end
+                                         end
+                 built_resource = Class.new(Avo::BaseResource) do |new_resource_class|
+                   self.model_class = model
+                   self.title = :brick_descrip
+                   self.includes = []
+                   if (!model.is_view? && mod_pk = model.primary_key)
+                     field((mod_pk.is_a?(Array) ? mod_pk.first : mod_pk).to_sym, { as: :id })
+                   end
+                   # Create a call such as:  field :name, as: :text
+                   fields.each do |f|
+                     # Add proper types if this is a polymorphic belongs_to
+                     if f.last == { as: :belongs_to } &&
+                        (fk = ::Brick.relations[model.table_name][:fks].find { |k, v| v[:assoc_name] == f.first.to_s }) &&
+                        fk.last.fetch(:polymorphic, nil)
+                       poly_types = fk.last.fetch(:inverse_table, nil)&.each_with_object([]) do |poly_table, s|
+                         s << Object.const_get(::Brick.relations[poly_table][:class_name])
+                       end
+                       if poly_types.present?
+                         f.last[:polymorphic_as] = f.first
+                         f.last[:types] = poly_types
+                       end
+                     end
+                     self.send(:field, *f)
+                   end
+                 end
+                 Object.const_set(requested.to_sym, built_resource)
+                 [built_resource, nil]
+               end
+
+             # MODEL
              elsif ::Brick.enable_models?
                # Custom inheritable Brick base model?
                class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
@@ -1397,14 +1377,19 @@ class Object
     end
 
     def build_controller(namespace, class_name, plural_class_name, model, relations)
+      if (is_avo = (namespace.name == 'Avo' && Object.const_defined?('Avo')))
+        # Basic Avo functionality is available via its own generic controller.
+        # (More information on https://docs.avohq.io/2.0/controllers.html)
+        controller_base = Avo::ResourcesController
+      end
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
 
-      code = +"class #{class_name} < ApplicationController\n"
-      built_controller = Class.new(ActionController::Base) do |new_controller_class|
+      code = +"class #{class_name} < #{controller_base&.name || 'ApplicationController'}\n"
+      built_controller = Class.new(controller_base || ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
         # Brick-specific pages
@@ -1501,118 +1486,120 @@ class Object
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
-        self.define_method :index do
-          if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
-             !params&.key?('_brick_schema') &&
-             (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
-            if params
-              referrer_params.each { |k, v| params.send(:parameters)[k] = v }
-            else
-              api_params = referrer_params&.to_h
+        unless is_avo
+          self.define_method :index do
+            if (is_openapi || request.env['REQUEST_PATH'].start_with?(::Brick.api_root)) &&
+               !params&.key?('_brick_schema') &&
+               (referrer_params = request.env['HTTP_REFERER']&.split('?')&.last&.split('&')&.map { |x| x.split('=') }).present?
+              if params
+                referrer_params.each { |k, v| params.send(:parameters)[k] = v }
+              else
+                api_params = referrer_params&.to_h
+              end
             end
-          end
-          _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
-
-          if is_openapi
-            json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
-                     'servers': [
-                       { 'url': '{scheme}://{defaultHost}', 'variables': {
-                         'scheme': { 'default': request.env['rack.url_scheme'] },
-                         'defaultHost': { 'default': request.env['HTTP_HOST'] }
-                       } }
-                     ]
-                   }
-            json['paths'] = relations.inject({}) do |s, relation|
-              unless ::Brick.config.enable_api == false
-                table_description = relation.last[:description]
-                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
-                  'get': {
-                    'summary': "list #{relation.first}",
-                    'description': table_description,
-                    'parameters': relation.last[:cols].map do |k, v|
-                                    param = { 'name' => k, 'schema': { 'type': v.first } }
-                                    if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                                      param['description'] = col_descrip
-                                    end
-                                    param
-                                  end,
-                    'responses': { '200': { 'description': 'successful' } }
-                  }
-                }
-
-                s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
-                  'patch': {
-                    'summary': "update a #{relation.first.singularize}",
-                    'description': table_description,
-                    'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
-                      param = { 'name' => k, 'schema': { 'type': v.first } }
-                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
-                        param['description'] = col_descrip
-                      end
-                      param
-                    end,
-                    'responses': { '200': { 'description': 'successful' } }
+            _schema, @_is_show_schema_list = ::Brick.set_db_schema(params || api_params)
+
+            if is_openapi
+              json = { 'openapi': '3.0.1', 'info': { 'title': Rswag::Ui.config.config_object[:urls].last&.fetch(:name, 'API documentation'), 'version': ::Brick.config.api_version },
+                       'servers': [
+                         { 'url': '{scheme}://{defaultHost}', 'variables': {
+                           'scheme': { 'default': request.env['rack.url_scheme'] },
+                           'defaultHost': { 'default': request.env['HTTP_HOST'] }
+                         } }
+                       ]
+                     }
+              json['paths'] = relations.inject({}) do |s, relation|
+                unless ::Brick.config.enable_api == false
+                  table_description = relation.last[:description]
+                  s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}"] = {
+                    'get': {
+                      'summary': "list #{relation.first}",
+                      'description': table_description,
+                      'parameters': relation.last[:cols].map do |k, v|
+                                      param = { 'name' => k, 'schema': { 'type': v.first } }
+                                      if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                                        param['description'] = col_descrip
+                                      end
+                                      param
+                                    end,
+                      'responses': { '200': { 'description': 'successful' } }
+                    }
                   }
-                } unless relation.last.fetch(:isView, nil)
-                s
+
+                  s["#{::Brick.config.api_root}#{relation.first.tr('.', '/')}/{id}"] = {
+                    'patch': {
+                      'summary': "update a #{relation.first.singularize}",
+                      'description': table_description,
+                      'parameters': relation.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
+                        param = { 'name' => k, 'schema': { 'type': v.first } }
+                        if (col_descrip = relation.last.fetch(:col_descrips, nil)&.fetch(k, nil))
+                          param['description'] = col_descrip
+                        end
+                        param
+                      end,
+                      'responses': { '200': { 'description': 'successful' } }
+                    }
+                  } unless relation.last.fetch(:isView, nil)
+                  s
+                end
               end
+              render inline: json.to_json, content_type: request.format
+              return
             end
-            render inline: json.to_json, content_type: request.format
-            return
-          end
 
-          if request.format == :csv # Asking for a template?
-            require 'csv'
-            exported_csv = CSV.generate(force_quotes: false) do |csv_out|
-              model.df_export(model.brick_import_template).each { |row| csv_out << row }
+            if request.format == :csv # Asking for a template?
+              require 'csv'
+              exported_csv = CSV.generate(force_quotes: false) do |csv_out|
+                model.df_export(model.brick_import_template).each { |row| csv_out << row }
+              end
+              render inline: exported_csv, content_type: request.format
+              return
+            elsif request.format == :js || request.path.start_with?('/api/') # Asking for JSON?
+              data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
+              render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
+              return
             end
-            render inline: exported_csv, content_type: request.format
-            return
-          elsif request.format == :js || request.path.start_with?('/api/') # Asking for JSON?
-            data = (model.is_view? || !Object.const_defined?('DutyFree')) ? model.limit(1000) : model.df_export(model.brick_import_template)
-            render inline: data.to_json, content_type: request.format == '*/*' ? 'application/json' : request.format
-            return
-          end
 
-          # Normal (not swagger or CSV) request
-
-          # %%% Allow params to define which columns to use for order_by
-          # Overriding the default by providing a querystring param?
-          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
-
-          ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
-          @_brick_params = ar_relation.brick_select(params, (selects = []), order_by,
-                                                             translations = {},
-                                                             join_array = ::Brick::JoinArray.new)
-          # %%% Add custom HM count columns
-          # %%% What happens when the PK is composite?
-          counts = model._br_hm_counts.each_with_object([]) do |v, s|
-            s << if is_mysql
-                   "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
-                 elsif is_postgres
-                   "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
-                 else
-                   "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
-                 end
-          end
-          ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
-          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
-          if namespace && (idx = lookup_context.prefixes.index(table_name))
-            lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
-          end
-          @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
-                           if (excl_parts = excl.split('.')).first == table_name
-                             s << excl_parts.last
+            # Normal (not swagger or CSV) request
+
+            # %%% Allow params to define which columns to use for order_by
+            # Overriding the default by providing a querystring param?
+            ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+            order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
+
+            ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
+            @_brick_params = ar_relation.brick_select(params, (selects = []), order_by,
+                                                               translations = {},
+                                                               join_array = ::Brick::JoinArray.new)
+            # %%% Add custom HM count columns
+            # %%% What happens when the PK is composite?
+            counts = model._br_hm_counts.each_with_object([]) do |v, s|
+              s << if is_mysql
+                     "`b_r_#{v.first}`.c_t_ AS \"b_r_#{v.first}_ct\""
+                   elsif is_postgres
+                     "\"b_r_#{v.first}\".c_t_ AS \"b_r_#{v.first}_ct\""
+                   else
+                     "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
+                   end
+            end
+            ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
+            instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
+            if namespace && (idx = lookup_context.prefixes.index(table_name))
+              lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
+            end
+            @_brick_excl = session[:_brick_exclude]&.split(',')&.each_with_object([]) do |excl, s|
+                             if (excl_parts = excl.split('.')).first == table_name
+                               s << excl_parts.last
+                             end
                            end
-                         end
-          @_brick_bt_descrip = model._br_bt_descrip
-          @_brick_hm_counts = model._br_hm_counts
-          @_brick_join_array = join_array
-          @_brick_erd = params['_brick_erd']&.to_i
+            @_brick_bt_descrip = model._br_bt_descrip
+            @_brick_hm_counts = model._br_hm_counts
+            @_brick_join_array = join_array
+            @_brick_erd = params['_brick_erd']&.to_i
+          end
         end
 
-        unless is_openapi
+        unless is_openapi || is_avo
           _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk)) if pk
           code << "  def index\n"
           code << "    @#{table_name.pluralize} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"

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

@@ -3,7 +3,7 @@
 module Brick
   module Rails
     # Extensions to rails controllers. Provides convenient ways to pass certain
-    # information to the model layer, with `controller_info` and `whodunnit`.
+    # information to the model layer, with `controller_info`.
     # Also includes a convenient on/off switch,
     # `brick_enabled_for_controller`.
     module Controller

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

@@ -4,6 +4,33 @@ module Brick
   module Rails
     # See http://guides.rubyonrails.org/engines.html
     class Engine < ::Rails::Engine
+      JS_CHANGEOUT = "function changeout(href, param, value, trimAfter) {
+  var hrefParts = href.split(\"?\");
+  var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
+  if (param === undefined || param === null || param === -1) {
+    hrefParts = hrefParts[0].split(\"://\");
+    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\").filter(function (pp) {return pp !== \"\";});
+    if (value === undefined)
+      // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
+      return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)[0]];
+    else {
+      var queryString = param ? \"?\" + params.join(\"&\") : \"\";
+      return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value + queryString;
+    }
+  }
+  if (trimAfter) {
+    var pathParts = hrefParts[0].split(\"/\");
+    while (pathParts.lastIndexOf(trimAfter) !== pathParts.length - 1) pathParts.pop();
+    hrefParts[0] = pathParts.join(\"/\");
+  }
+  params = params.reduce(function (s, v) { var parts = v.split(\"=\"); if (parts[1]) s[parts[0]] = parts[1]; return s; }, {});
+  if (value === undefined) return params[param];
+  params[param] = value;
+  var finalParams = Object.keys(params).reduce(function (s, v) { if (params[v]) s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
+  return hrefParts[0] + (finalParams.length > 0 ? \"?\" + finalParams : \"\");
+}
+"
+
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
       config.brick = ActiveSupport::OrderedOptions.new
       ActiveSupport.on_load(:before_initialize) do |app|
@@ -61,6 +88,167 @@ module Brick
           (app_config.assets.precompile ||= []) << "#{assets_path}/images/brick_erd.png"
           (app.config.assets.paths ||= []) << assets_path
         end
+
+        # Smarten up Avo so it recognises Brick's querystring option for Apartment multi-tenancy
+        if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace)
+          module ::Avo
+            class ApplicationController
+              # Make Avo tenant-compatible when a querystring param is included such as:  ?_brick_schema=globex_corp
+              alias _brick_avo_init init_app
+              def init_app
+                _brick_avo_init
+                ::Brick.set_db_schema(params)
+              end
+            end
+
+            module UrlHelpers
+              alias _brick_resource_path resource_path
+              # Accommodate STI resources
+              def resource_path(model:, resource:, **args)
+                resource ||= if (klass = model&.class)
+                               Avo::App.resources.find { |r| r.model_class > klass }
+                             end
+                _brick_resource_path(model: model, resource: resource, **args)
+              end
+            end
+
+            class Fields::BelongsToField
+              # When there is no Resource created for the target of a belongs_to, defer to the description that Brick would use
+              alias _brick_label label
+              def label
+                target_resource ? _brick_label : value.send(:brick_descrip)
+              end
+            end
+
+            class App
+              class << self
+                alias _brick_eager_load eager_load
+                def eager_load(entity)
+                  _brick_eager_load(entity)
+                  if entity == :resources
+                    # %%% This useful logic can be DRYd up since it's very similar to what's around extensions.rb:1894
+                    if (possible_schemas = (multitenancy = ::Brick.config.schema_behavior&.[](:multitenant)) &&
+                                           multitenancy&.[](:schema_to_analyse))
+                      possible_schemas = [possible_schemas] unless possible_schemas.is_a?(Array)
+                      if (possible_schema = possible_schemas.find { |ps| ::Brick.db_schemas.key?(ps) })
+                        orig_tenant = Apartment::Tenant.current
+                        Apartment::Tenant.switch!(possible_schema)
+                      end
+                    end
+                    existing = Avo::BaseResource.descendants.each_with_object({}) do |r, s|
+                                 s[r.name[0..-9]] = nil if r.name.end_with?('Resource')
+                               end
+                    ::Brick.relations.each do |k, v|
+                      unless existing.key?(class_name = v[:class_name]) || Brick.config.exclude_tables.include?(k) || class_name.blank?
+                        Object.const_get("#{class_name}Resource")
+                      end
+                    end
+                    Apartment::Tenant.switch!(orig_tenant) if orig_tenant
+                  end
+                end
+              end
+            end
+
+            # Add our schema link Javascript code when the TurboFrameWrapper is rendered so it ends up on all index / show / etc
+            TurboFrameWrapperComponent.class_exec do
+              alias _brick_content content
+              def content
+                # Avo's logo partial fails if there is not a URL helper called exactly "root_path"
+                # (Finicky line over there is:  avo/app/views/avo/partials/_logo.html.erb:1)
+                if ::Brick.instance_variable_get(:@_brick_avo_js) == view_renderer.object_id
+                  _brick_content
+                else
+                  ::Brick.instance_variable_set(:@_brick_avo_js, view_renderer.object_id)
+                  unless ::Rails.application.routes.named_routes.names.include?(:root) || ActionView::Base.respond_to?(:root_path)
+                    ActionView::Base.class_exec do
+                      def root_path
+                        Avo::App.root_path
+                      end
+                    end
+                  end
+"<script>
+#{JS_CHANGEOUT}
+window.addEventListener(\"load\", linkSchemas);
+document.addEventListener(\"turbo:render\", linkSchemas);
+window.addEventListener(\"popstate\", linkSchemas);
+// [... document.getElementsByTagName('turbo-frame')].forEach(function (a) { a.addEventListener(\"turbo:frame-render\", linkSchemas); });
+function linkSchemas() {
+  brickSchema = changeout(location.href, \"_brick_schema\");
+  if (brickSchema) {
+    [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
+    [... document.getElementsByTagName(\"FORM\")].forEach(function (form) { form.action = changeout(form.action, \"_brick_schema\", brickSchema); });
+  }
+}
+</script>
+#{_brick_content}".html_safe
+                end
+              end
+            end
+
+            # When available, add a clickable brick icon to go to the Brick version of the page
+            PanelComponent.class_exec do
+              alias _brick_init initialize
+              def initialize(*args)
+                _brick_init(*args)
+                @name = BrickTitle.new(@name, self)
+              end
+            end
+
+            class BrickTitle
+              def initialize(name, view_component)
+                @vc = view_component
+                @_name = name
+              end
+              def to_s
+                @_name.html_safe + @vc.instance_variable_get(:@__vc_helpers)&.link_to_brick(nil,
+                  "<svg version=\"1.1\" style=\"display: inline; padding-left: 0.5em;\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"
+  viewBox=\"0 0 58 58\" height=\"1.4em\" xml:space=\"preserve\">
+<g>
+  <polygon style=\"fill:#C2615F;\" points=\"58,15.831 19.106,35.492 0,26.644 40,6\"/>
+  <polygon style=\"fill:#6D4646;\" points=\"19,52 0,43.356 0,26.644 19,35\"/>
+  <polygon style=\"fill:#894747;\" points=\"58,31.559 19,52 19,35 58,15.831\"/>
+</g>
+</svg>
+".html_safe,
+                  { title: "#{@_name} in Brick" }
+                )
+              end
+            end
+
+            class Fields::IndexComponent
+              alias _brick_resource_view_path resource_view_path
+              def resource_view_path
+                return if @resource.model&.class&.is_view?
+
+                _brick_resource_view_path
+              end
+            end
+          end # module Avo
+
+          # Steer any Avo-related controller/action based URL lookups to the Avo RouteSet
+          class ActionDispatch::Routing::RouteSet
+            alias _brick_url_for url_for
+            def url_for(options, *args)
+              if self != ::Avo.railtie_routes_url_helpers._routes && # This URL lookup is not on the Avo RouteSet ...
+                 (options[:controller]&.start_with?('avo/') || # ... but it is based on an Avo controller and action?
+                  options[:_recall]&.fetch(:controller, nil)&.start_with?('avo/')
+                 )
+                options[:script_name] = ::Avo.configuration.root_path if options[:script_name].blank?
+                ::Avo.railtie_routes_url_helpers._routes.url_for(options, *args) # Go get the answer from the real Avo RouteSet
+              # Views currently do not support show / new / edit
+              elsif options[:controller]&.start_with?('avo/') &&
+                    ['show', 'new', 'edit'].include?(options[:action]) &&
+                    ((options[:id].is_a?(ActiveRecord::Base) && options[:id].class.is_view?) ||
+                     ::Brick.relations.fetch(options[:controller][4..-1], nil)&.fetch(:isView, nil)
+                    )
+                nil
+              else # This is either a non-Avo request or a proper Avo request, so carry on
+                _brick_url_for(options, *args)
+              end
+            end
+          end
+        end # Avo compatibility
+
         # ====================================
         # Dynamically create generic templates
         # ====================================
@@ -93,15 +281,15 @@ module Brick
               end
             end
 
-            def path_keys(hm_assoc, fk_name, obj_name, pk)
+            def path_keys(hm_assoc, fk_name, pk)
+              pk.map!(&:to_sym)
               keys = if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
-                       fk_name.zip(pk.map { |fk_part| "#{obj_name}.#{fk_part}" })
+                       fk_name.zip(pk)
                      else
-                       pk = pk.map { |pk_part| "#{obj_name}.#{pk_part}" }
                        [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
                      end
               keys << [hm_assoc.inverse_of.foreign_type, hm_assoc.active_record.name] if hm_assoc.options.key?(:as)
-              keys.map { |x| "#{x.first}: #{x.last}"}.join(', ')
+              keys.to_h
             end
 
             alias :_brick_find_template :find_template
@@ -138,8 +326,6 @@ module Brick
                               "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if (through = hm_assoc.options[:through])
-                                 next unless @_brick_model._br_hm_counts.key?(hm_assoc.name) # Skip any weird HMTs that go through a HM with a source_type
-
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
@@ -154,33 +340,30 @@ module Brick
                                    tbl_nm.slice!(0) if tbl_nm[0] == '/'
                                    tbl_nm = tbl_nm.tr('/', '_').pluralize
                                  end
-                                 "'#{tbl_nm}.#{associative.foreign_key}'"
+                                 "#{tbl_nm}.#{associative.foreign_key}"
                                else
                                  hm_assoc.foreign_key
                                end
                   case args.first
                   when 'index'
-                    hm_entry = +"'#{hm_assoc.name}' => [#{assoc_name.inspect}"
-                    hm_entry << if hm_assoc.macro == :has_many
-                                   if hm_fk_name # %%% Can remove this check when multiple foreign keys to same destination becomes bulletproof
-                                     set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
-                                                 'nil'
-                                               else
-                                                 # Postgres column names are limited to 63 characters
-                                                 "#{obj_name}.#{"b_r_#{assoc_name}_ct"[0..62]}&.to_i || 0"
-                                               end
-                                     ", #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
-                                   end
-                                 else # has_one
-                                   # 0..62 because Postgres column names are limited to 63 characters
-                                   ", nil, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
-                                 end
-                    hm_entry << ']'
-                    hms_columns << hm_entry
+                    unless skip_klass_hms.key?(assoc_name.to_sym) || hm_assoc.options[:source]
+                      hm_entry = +"'#{hm_assoc.name}' => [#{assoc_name.inspect}, "
+                      hm_entry << if hm_assoc.macro == :has_many
+                                    # Postgres column names are limited to 63 characters
+                                    "'" + "b_r_#{assoc_name}_ct"[0..62] + "'"
+                                  else # has_one
+                                    'nil'
+                                  end
+                      hm_entry << ", #{path_keys(hm_assoc, hm_fk_name, pk).inspect}]"
+                      hms_columns << hm_entry
+                    end
                   when 'show', 'new', 'update'
                     hm_stuff << if hm_fk_name
                                   if hm_assoc.klass.column_names.include?(hm_fk_name)
-                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                                    predicates = path_keys(hm_assoc, hm_fk_name, pk).map do |k, v|
+                                                   v.is_a?(String) ? "#{k}: '#{v}'" : "#{k}: @#{obj_name}.#{v}"
+                                                 end.join(', ')
+                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{predicates} }) %>\n"
                                   else
                                     puts "Warning:  has_many :#{hm_assoc.name} in model #{hm_assoc.active_record.name} currently looks for a foreign key called \"#{hm_assoc.foreign_key}\".  "\
                                          "Instead it should use the clause  \"foreign_key: :#{hm_assoc.inverse_of&.foreign_key}\"."
@@ -437,7 +620,18 @@ end
 def slashify(*vals)
   vals.map { |val_part| val_part.is_a?(String) ? val_part.gsub('/', '^^sl^^') : val_part }
 end
-callbacks = {} %>"
+callbacks = {} %>
+
+<% avo_svg = \"#{
+"<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 84 90\" height=\"30\" fill=\"#3096F7\">
+  <path d=\"M83.8304 81.0201C83.8343 82.9343 83.2216 84.7996 82.0822 86.3423C80.9427 87.8851 79.3363 89.0244 77.4984 89.5931C75.6606 90.1618 73.6878 90.1302 71.8694 89.5027C70.0509 88.8753 68.4823 87.6851 67.3935 86.1065L67.0796 85.6029C66.9412 85.378 66.8146 85.1463 66.6998 84.9079L66.8821 85.3007C64.1347 81.223 60.419 77.8817 56.0639 75.5723C51.7087 73.263 46.8484 72.057 41.9129 72.0609C31.75 72.0609 22.372 77.6459 16.9336 85.336C17.1412 84.7518 17.7185 83.6137 17.9463 83.0446L19.1059 80.5265L19.1414 80.456C25.2533 68.3694 37.7252 59.9541 52.0555 59.9541C53.1949 59.9541 54.3241 60.0095 55.433 60.1102C60.748 60.6134 65.8887 62.2627 70.4974 64.9433C75.1061 67.6238 79.0719 71.2712 82.1188 75.6314C82.1188 75.6314 82.1441 75.6717 82.1593 75.6868C82.1808 75.717 82.1995 75.749 82.215 75.7825C82.2821 75.8717 82.3446 75.9641 82.4024 76.0595C82.4682 76.1653 82.534 76.4221 82.5999 76.5279C82.6657 76.6336 82.772 76.82 82.848 76.9711L83.1822 77.7063C83.6094 78.7595 83.8294 79.8844 83.8304 81.0201V81.0201Z\" fill=\"currentColor\" fill-opacity=\"0.22\"></path>
+  <path opacity=\"0.25\" d=\"M83.8303 81.015C83.8354 82.9297 83.2235 84.7956 82.0844 86.3393C80.9453 87.8829 79.339 89.0229 77.5008 89.5923C75.6627 90.1617 73.6895 90.1304 71.8706 89.5031C70.0516 88.8758 68.4826 87.6854 67.3935 86.1065L67.0796 85.6029C66.9412 85.3746 66.8146 85.1429 66.6998 84.9079L66.8821 85.3007C64.1353 81.222 60.4199 77.8797 56.0647 75.5695C51.7095 73.2593 46.8488 72.0524 41.9129 72.0558C31.75 72.0558 22.372 77.6408 16.9336 85.3309C17.1412 84.7467 17.7185 83.6086 17.9463 83.0395L19.1059 80.5214L19.1414 80.4509C22.1906 74.357 26.8837 69.2264 32.6961 65.6326C38.5086 62.0387 45.2114 60.1232 52.0555 60.1001C53.1949 60.1001 54.3241 60.1555 55.433 60.2562C60.7479 60.7594 65.8887 62.4087 70.4974 65.0893C75.1061 67.7698 79.0719 71.4172 82.1188 75.7775C82.1188 75.7775 82.1441 75.8177 82.1593 75.8328C82.1808 75.863 82.1995 75.895 82.215 75.9285C82.2821 76.0177 82.3446 76.1101 82.4024 76.2055L82.5999 76.5228C82.6859 76.6638 82.772 76.8149 82.848 76.966L83.1822 77.7012C83.6093 78.7544 83.8294 79.8793 83.8303 81.015Z\" fill=\"currentColor\" fill-opacity=\"0.22\"></path>
+  <path d=\"M42.1155 30.2056L35.3453 45.0218C35.2161 45.302 35.0189 45.5458 34.7714 45.7313C34.5239 45.9168 34.2338 46.0382 33.9274 46.0844C27.3926 47.1694 21.1567 49.5963 15.617 53.2105C15.279 53.4302 14.8783 53.5347 14.4753 53.5083C14.0723 53.4819 13.6889 53.326 13.3827 53.0641C13.0765 52.8022 12.8642 52.4485 12.7777 52.0562C12.6911 51.6638 12.7351 51.2542 12.9029 50.8889L32.2311 8.55046L33.6894 5.35254C32.8713 7.50748 32.9166 9.89263 33.816 12.0153L33.9983 12.4131L42.1155 30.2056Z\" fill=\"currentColor\" fill-opacity=\"0.22\"></path>
+  <path d=\"M82.812 76.8753C82.6905 76.694 82.3715 76.2207 82.2449 76.0444C82.2044 75.9739 82.2044 75.8782 82.1588 75.8127C82.1132 75.7473 82.1335 75.7724 82.1183 75.7573C79.0714 71.3971 75.1056 67.7497 70.4969 65.0692C65.8882 62.3886 60.7474 60.7393 55.4325 60.2361C54.3236 60.1354 53.1943 60.08 52.055 60.08C45.2173 60.1051 38.5214 62.022 32.7166 65.6161C26.9118 69.2102 22.2271 74.3397 19.1864 80.4308L19.151 80.5013C18.7358 81.3323 18.3458 82.1784 17.9914 83.0194L16.9786 85.2655C16.9077 85.3662 16.8419 85.472 16.771 85.5828C16.6647 85.7389 16.5584 85.9 16.4621 86.0612C15.3778 87.6439 13.8123 88.8397 11.995 89.4732C10.1776 90.1068 8.20406 90.1448 6.36344 89.5817C4.52281 89.0186 2.9119 87.884 1.76676 86.3442C0.621625 84.8044 0.00246102 82.9403 0 81.0251C0.00604053 80.0402 0.177178 79.0632 0.506372 78.1344L1.22036 76.5681C1.25084 76.5034 1.28639 76.4411 1.32669 76.3818C1.40265 76.2559 1.47861 76.135 1.56469 76.0192C1.58531 75.9789 1.60901 75.9401 1.63558 75.9034C7.06401 67.6054 14.947 61.1866 24.1977 57.5317C33.4485 53.8768 43.6114 53.166 53.2855 55.4971L48.9155 45.9286L41.9276 30.6188L33.8256 12.8263L33.6433 12.4285C32.7439 10.3058 32.6986 7.92067 33.5167 5.76573L34.0231 4.69304C34.8148 3.24136 35.9941 2.03525 37.431 1.20762C38.868 0.379997 40.5068 -0.0370045 42.1668 0.0025773C43.8268 0.0421591 45.4436 0.536787 46.839 1.43195C48.2345 2.32711 49.3543 3.58804 50.0751 5.07578L50.2523 5.47363L51.8474 8.96365L74.0974 57.708L82.812 76.8753Z\" fill=\"currentColor\" fill-opacity=\"0.22\"></path>
+  <path opacity=\"0.25\" d=\"M41.9129 30.649L35.3301 45.0422C35.2023 45.3204 35.0074 45.563 34.7627 45.7484C34.518 45.9337 34.2311 46.0562 33.9274 46.1048C27.3926 47.1897 21.1567 49.6166 15.617 53.2308C15.279 53.4505 14.8783 53.555 14.4753 53.5286C14.0723 53.5022 13.6889 53.3463 13.3827 53.0844C13.0765 52.8225 12.8642 52.4688 12.7777 52.0765C12.6911 51.6842 12.7351 51.2745 12.9029 50.9092L32.0285 8.99382L33.4869 5.7959C32.6687 7.95084 32.7141 10.336 33.6135 12.4586L33.7958 12.8565L41.9129 30.649Z\" fill=\"currentColor\" fill-opacity=\"0.22\"></path>
+</svg>
+".gsub('"', '\"')
+}\".html_safe %>"
 
               if ['index', 'show', 'new', 'update'].include?(args.first)
                 poly_cols = []
@@ -520,31 +714,7 @@ document.querySelectorAll(\"input[type=submit][data-confirm]\").forEach(function
   });
 });
 
-function changeout(href, param, value, trimAfter) {
-  var hrefParts = href.split(\"?\");
-  var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
-  if (param === undefined || param === null || param === -1) {
-    hrefParts = hrefParts[0].split(\"://\");
-    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\").filter(function (pp) {return pp !== \"\";});
-    if (value === undefined)
-      // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
-      return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)[0]];
-    else {
-      var queryString = param ? \"?\" + params.join(\"&\") : \"\";
-      return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value + queryString;
-    }
-  }
-  if (trimAfter) {
-    var pathParts = hrefParts[0].split(\"/\");
-    while (pathParts.lastIndexOf(trimAfter) !== pathParts.length - 1) pathParts.pop();
-    hrefParts[0] = pathParts.join(\"/\");
-  }
-  params = params.reduce(function (s, v) { var parts = v.split(\"=\"); if (parts[1]) s[parts[0]] = parts[1]; return s; }, {});
-  if (value === undefined) return params[param];
-  params[param] = value;
-  var finalParams = Object.keys(params).reduce(function (s, v) { if (params[v]) s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
-  return hrefParts[0] + (finalParams.length > 0 ? \"?\" + finalParams : \"\");
-}
+#{JS_CHANGEOUT}
 
 // Snag first TR for sticky header
 var grid = document.getElementById(\"#{table_name}\");
@@ -730,11 +900,6 @@ erDiagram
                            end
               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(', ')}" unless pk.empty?
-                                  elsif pk
-                                    "#{obj_name}.#{pk}"
-                                  end
                          if Object.const_defined?('DutyFree')
                            template_link = "
   <%= link_to 'CSV', #{@_brick_model._brick_index}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
@@ -842,6 +1007,15 @@ erDiagram
 <table id=\"resourceName\"><tr>
   <td><h1>#{model_name}</h1></td>
   <td id=\"imgErd\" title=\"Show ERD\"></td>
+  <% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) %>
+    <td><%= link_to_brick(
+        avo_svg,
+        { index_proc: Proc.new do |model|
+                        ::Avo.railtie_routes_url_helpers.send(\"resources_#\{model.base_class.model_name.route_key}_path\".to_sym)
+                      end,
+          title: '#{model_name} in Avo' }
+      ) %></td>
+  <% end %>
 </tr></table>#{template_link}<%
    if description.present? %><%=
      description %><br><%
@@ -875,149 +1049,36 @@ erDiagram
   </script>
 <% end %>
 #{erd_markup}
-<table id=\"headerTop\"></table>
-<table id=\"#{table_name}\" class=\"shadow\">
-  <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%=
-     # Consider getting the name from the association -- hm.first.name -- if a more \"friendly\" alias should be used for a screwy table name
-     cols = {#{hms_keys = []
-               hms_headers.map do |hm|
-                 hms_keys << (assoc_name = (assoc = hm.first).name.to_s)
-                 "#{assoc_name.inspect} => [#{(assoc.options[:through] && !assoc.through_reflection).inspect}, #{assoc.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
-               end.join(', ')}}
-     # If the resource is missing, has the user simply created an inappropriately pluralised name for a table?
-     @#{table_name} ||= if dym_list = instance_variables.reject do |entry|
-                             entry.to_s.start_with?('@_') ||
-                             ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
-                           end
-                          msg = \"Can't find resource \\\"#{table_name}\\\".\"
-                           # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
-                          if (dym = DidYouMean::SpellChecker.new(dictionary: dym_list).correct('@#{table_name}')).present?
-                            msg << \"\nIf you meant \\\"#\{found_dym = dym.first[1..-1]}\\\" then to avoid this message add this entry into inflections.rb:\n\"
-                            msg << \"  inflect.singular('#\{found_dym}', '#{obj_name}')\"
-                            puts
-                            puts \"WARNING:  #\{msg}\"
-                            puts
-                            @#{table_name} = instance_variable_get(dym.first.to_sym)
-                          else
-                            raise ActiveRecord::RecordNotFound.new(msg)
+
+<%= # Consider getting the name from the association -- hm.first.name -- if a more \"friendly\" alias should be used for a screwy table name
+    cols = {#{hms_keys = []
+              hms_headers.map do |hm|
+                hms_keys << (assoc_name = (assoc = hm.first).name.to_s)
+                "#{assoc_name.inspect} => [#{(assoc.options[:through] && !assoc.through_reflection).inspect}, #{assoc.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
+              end.join(', ')}}
+
+    # If the resource is missing, has the user simply created an inappropriately pluralised name for a table?
+    @#{table_name} ||= if dym_list = instance_variables.reject do |entry|
+                            entry.to_s.start_with?('@_') ||
+                            ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
                           end
-                        end
-     col_keys = @#{table_name}.columns.each_with_object([]) do |col, s|
-       col_name = col.name
-       next if @_brick_incl&.exclude?(col_name) ||
-               (#{(pk || []).inspect}.include?(col_name) && col.type == :integer && !bts.key?(col_name)) ||
-               ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
-
-       s << col_name
-       cols[col_name] = col
-     end
-     unless @_brick_sequence # If no sequence is defined, start with all inclusions
-       cust_cols = #{model_name}._br_cust_cols
-       # HOT columns, kept as symbols
-       hots = #{model_name}._br_bt_descrip.keys.select { |k| bts.key?(k) }
-       @_brick_sequence = col_keys + cust_cols.keys + hots + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
-     end
-     @_brick_sequence.reject! { |nm| @_brick_excl.include?(nm) } if @_brick_excl # Reject exclusions
-     @_brick_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 \" +
-                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
-         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\"))}\")
-       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}\"
-       end
-       s << '</th>'
-     end.html_safe
-  %></tr></thead>
-  <tbody>
-  <% # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
-     #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
-     #     TinyTds::Error: Adaptive Server connection timed out
-     #     (After restarting the server it worked fine again.)
-     @#{table_name}.each do |#{obj_name}|
-       hms_cols = {#{hms_columns.join(', ')}} %>
-  <tr>#{"
-    <td><%= link_to '⇛', #{path_obj_name}_path(slashify(#{obj_pk})), { class: 'big-arrow' } %></td>" if obj_pk}
-    <% @_brick_sequence.each do |col_name|
-         val = #{obj_name}.attributes[col_name] %>
-      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name) || (cust_col = cust_cols[col_name]) || 
-                                                  (col_name.is_a?(Symbol) && bts.key?(col_name)) # HOT
-         %>><%
-         if (bt = bts[col_name])
-           if bt[2] # Polymorphic?
-             bt_class = #{obj_name}.send(\"#\{bt.first}_type\")
-             base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
-             poly_id = #{obj_name}.send(\"#\{bt.first}_id\")
-             %><%= link_to(\"#\{bt_class} ##\{poly_id}\", send(\"#\{base_class_underscored}_path\".to_sym, poly_id)) if poly_id %><%
-           else # BT or HOT
-             bt_class = bt[1].first.first
-             descrips = @_brick_bt_descrip[bt.first][bt_class]
-             bt_id_col = if descrips.nil?
-                           puts \"Caught it in the act for #{obj_name} / #\{col_name}!\"
-                           # binding.pry
-                         elsif descrips.length == 1
-                           [#{obj_name}.class.reflect_on_association(bt.first)&.foreign_key]
+                         msg = \"Can't find resource \\\"#{table_name}\\\".\"
+                          # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
+                         if (dym = DidYouMean::SpellChecker.new(dictionary: dym_list).correct('@#{table_name}')).present?
+                           msg << \"\nIf you meant \\\"#\{found_dym = dym.first[1..-1]}\\\" then to avoid this message add this entry into inflections.rb:\n\"
+                           msg << \"  inflect.singular('#\{found_dym}', '#{obj_name}')\"
+                           puts
+                           puts \"WARNING:  #\{msg}\"
+                           puts
+                           @#{table_name} = instance_variable_get(dym.first.to_sym)
                          else
-                           descrips.last
+                           raise ActiveRecord::RecordNotFound.new(msg)
                          end
-             bt_txt = bt_class.brick_descrip(
-               # 0..62 because Postgres column names are limited to 63 characters
-               #{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, bt_id_col
-             )
-             bt_txt ||= \"<span class=\\\"orphan\\\">&lt;&lt; Orphaned ID: #\{val} >></span>\".html_safe if val
-             bt_id = bt_id_col&.map { |id_col| #{obj_name}.respond_to?(id_sym = id_col.to_sym) ? #{obj_name}.send(id_sym) : id_col } %>
-          <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class._brick_index(:singular)}_path\".to_sym, bt_id)) : bt_txt %>
-        <% end
-         elsif (hms_col = hms_cols[col_name])
-           if hms_col.length == 1 %>
-        <%=  hms_col.first %>
-        <% else
-    %><%=    klass = (col = cols[col_name])[1]
-             if col[2] == 'HO'
-               descrips = @_brick_bt_descrip[col_name.to_sym][klass]
-               if (ho_id = (ho_id_col = descrips.last).map { |id_col| #{obj_name}.send(id_col.to_sym) })&.first
-                 ho_txt = klass.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, ho_id_col)
-                 link_to(ho_txt, send(\"#\{klass.base_class._brick_index(:singular)}_path\".to_sym, ho_id))
-               end
-             elsif hms_col[1]&.positive?
-               link_to \"#\{hms_col[1] || 'View'} #\{hms_col.first}\", send(\"#\{klass._brick_index}_path\".to_sym, hms_col[2])
-             end %>
-        <% end
-         elsif (col = cols[col_name])
-           col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
-    %><%=  display_value(col_type || col&.sql_type, val) %><%
-         elsif cust_col
-           data = cust_col.first.map { |cc_part| #{obj_name}.send(cc_part.last) }
-           cust_txt = #{model_name}.brick_descrip(cust_col[-2], data)
-           if (link_id = #{obj_name}.send(cust_col.last[1]) if cust_col.last)
-    %><%=    link_to(cust_txt, send(\"#\{cust_col.last.first._brick_index(:singular)}_path\", link_id)) %><%
-           else
-    %><%=    cust_txt %><%
-           end
-         else # Bad column name!
-      %>?<%
-         end
-    %></td>
-    <% end %>
-  </tr>
-  <% end %>
-  </tbody>
-</table>
+                       end
+
+    # Write out the mega-grid
+    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?}
 #{script}
@@ -1125,7 +1186,18 @@ erDiagram
 <p style=\"color: green\"><%= notice %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
-<h1><%= page_title %></h1><%
+<table><td><h1><%= page_title %></h1></td>
+<% if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) %>
+  <td><%= link_to_brick(
+      avo_svg,
+      { show_proc: Proc.new do |obj|
+                     ::Avo.railtie_routes_url_helpers.send(\"resources_#\{obj.class.base_class.model_name.singular_route_key}_path\".to_sym, obj)
+                   end,
+        title: \"#\{page_title} in Avo\" }
+    ) %></td>
+<% end %>
+</table>
+<%
 if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
   description %><br><%
 end

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

@@ -0,0 +1,219 @@
+module Brick::Rails::FormTags
+  # Our super speedy grid
+  def brick_grid(relation, bt_descrip, sequence = nil, inclusions, exclusions,
+                 cols, poly_cols, bts, hms_keys, hms_cols)
+    out = "<table id=\"headerTop\"></table>
+<table id=\"#{relation.table_name}\" class=\"shadow\">
+  <thead><tr>"
+    pk = (klass = relation.klass).primary_key || []
+    pk = [pk] unless pk.is_a?(Array)
+    if pk.present?
+      out << "<th x-order=\"#{pk.join(',')}\"></th>"
+    end
+
+    col_keys = relation.columns.each_with_object([]) do |col, s|
+      col_name = col.name
+      next if inclusions&.exclude?(col_name) ||
+              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts.key?(col_name)) ||
+              ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
+
+      s << col_name
+      cols[col_name] = col
+    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) }
+    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 " +
+                    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
+             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"))}")
+           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}"
+           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
+  #     ActiveRecord::StatementTimeout in Warehouse::ColdRoomTemperatures_Archive#index
+  #     TinyTds::Error: Adaptive Server connection timed out
+  #     (After restarting the server it worked fine again.)
+  relation.each do |obj|
+    out << "<tr>\n"
+    out << "<td>#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym,
+                                    pk.map { |pk_part| obj.send(pk_part.to_sym) }), { class: 'big-arrow' })}</td>\n" if pk.present?
+    sequence.each do |col_name|
+      val = obj.attributes[col_name]
+      out << '<td'
+      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[2] # Polymorphic?
+          bt_class = obj.send("#{bt.first}_type")
+          base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
+          poly_id = obj.send("#{bt.first}_id")
+          out << link_to("#{bt_class} ##{poly_id}", send("#{base_class_underscored}_path".to_sym, poly_id)) if poly_id
+        else # BT or HOT
+          bt_class = bt[1].first.first
+          descrips = bt_descrip[bt.first][bt_class]
+          bt_id_col = if descrips.nil?
+                        puts "Caught it in the act for obj / #{col_name}!"
+                      elsif descrips.length == 1
+                        [obj.class.reflect_on_association(bt.first)&.foreign_key]
+                      else
+                        descrips.last
+                      end
+          bt_txt = bt_class.brick_descrip(
+            # 0..62 because Postgres column names are limited to 63 characters
+            obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, bt_id_col
+          )
+          bt_txt ||= "<span class=\"orphan\">&lt;&lt; Orphaned ID: #{val} >></span>" if val
+          bt_id = bt_id_col&.map { |id_col| obj.respond_to?(id_sym = id_col.to_sym) ? obj.send(id_sym) : id_col }
+          out << (bt_id&.first ? link_to(bt_txt, send("#{bt_class.base_class._brick_index(:singular)}_path".to_sym, bt_id)) : bt_txt || '')
+        end
+      elsif (hms_col = hms_cols[col_name])
+        if hms_col.length == 1
+          out << hms_col.first
+        else
+          klass = (col = cols[col_name])[1]
+          if col[2] == 'HO'
+            descrips = bt_descrip[col_name.to_sym][klass]
+            if (ho_id = (ho_id_col = descrips.last).map { |id_col| obj.send(id_col.to_sym) })&.first
+              ho_txt = klass.brick_descrip(obj, descrips[0..-2].map { |id| obj.send(id.last[0..62]) }, ho_id_col)
+              out << link_to(ho_txt, send("#{klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
+            end
+          else
+            if (ct = obj.send(hms_col[1].to_sym)&.to_i)&.positive?
+              out << "#{link_to("#{ct || 'View'} #{hms_col.first}",
+                                   send("#{klass._brick_index}_path".to_sym,
+                                        hms_col[2].each_with_object({}) { |v, s| s[v.first] = v.last.is_a?(String) ? v.last : obj.send(v.last) })
+                               )}\n"
+            end
+          end
+        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
+      elsif cust_col
+        data = cust_col.first.map { |cc_part| obj.send(cc_part.last) }
+        cust_txt = klass.brick_descrip(cust_col[-2], data)
+        if (link_id = obj.send(cust_col.last[1]) if cust_col.last)
+          out << link_to(cust_txt, send("#{cust_col.last.first._brick_index(:singular)}_path", link_id))
+        else
+          out << cust_txt
+        end
+      else # Bad column name!
+        out << '?'
+      end
+      out << '</td>'
+    end
+  out << '</tr>'
+  end
+  out << "  </tbody>
+</table>
+"
+    out.html_safe
+  end # brick_grid
+
+  def link_to_brick(*args, **kwargs)
+    return unless ::Brick.config.mode == :on
+
+    text = ((args.first.is_a?(String) || args.first.is_a?(Proc)) && args.shift) || args[1]
+    text = text.call if text.is_a?(Proc)
+    klass_or_obj = ((args.first.is_a?(ActiveRecord::Relation) ||
+                     args.first.is_a?(ActiveRecord::Base) ||
+                     args.first.is_a?(Class)) &&
+                    args.first) ||
+                   @_brick_model
+    # If not provided, do a best-effort to automatically determine the resource class or object
+    filter_parts = []
+    klass_or_obj ||= begin
+                       klass, sti_type = ::Brick.ctrl_to_klass(controller_path)
+                       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)
+                         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
+                         else
+                           # %%% If there is a HMT that refers to some ___id then try to identify an appropriate filter
+                           # %%% 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]}"
+                           end
+                           klass
+                         end
+                       end
+                     rescue
+                     end
+    if klass_or_obj
+      if klass_or_obj.is_a?(ActiveRecord::Relation)
+        klass_or_obj.where_values_hash.each do |whr|
+          filter_parts << "#{whr.first}=#{whr.last}" if whr.last && !whr.last.is_a?(Array)
+        end
+        klass_or_obj = klass_or_obj.klass
+        type_col = klass_or_obj.inheritance_column
+        if klass_or_obj.column_names.include?(type_col) && klass_or_obj.name != klass_or_obj.base_class.name
+          filter_parts << "#{type_col}=#{klass_or_obj.name}"
+        end
+      end
+      filter = "?#{filter_parts.join('&')}" if filter_parts.present?
+      if (klass_or_obj&.is_a?(Class) && klass_or_obj < ActiveRecord::Base) ||
+         (klass_or_obj&.is_a?(ActiveRecord::Base) && klass_or_obj.new_record? && (klass_or_obj = klass_or_obj.class))
+        path = (proc = kwargs[:index_proc]) ? proc.call(klass_or_obj) : "#{send("#{klass_or_obj.base_class._brick_index}_path")}#{filter}"
+        lt_args = [text || "Index for #{klass_or_obj.name.pluralize}", path]
+      else
+        # If there are multiple incoming parameters then last one is probably the actual ID, and first few might be some nested tree of stuff leading up to it
+        path = (proc = kwargs[:show_proc]) ? proc.call(klass_or_obj) : "#{send("#{klass_or_obj.class.base_class._brick_index(:singular)}_path", klass_or_obj)}#{filter}"
+        lt_args = [text || "Show this #{klass_or_obj.class.name}", path]
+      end
+      link_to(*lt_args, **kwargs)
+    else
+      # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
+      # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
+      links = instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
+                iv_name = name.to_s[1..-1]
+                case (val = instance_variable_get(name))
+                when ActiveRecord::Relation
+                  s[val.klass] << iv_name
+                when ActiveRecord::Base
+                  s[val] << iv_name
+                end
+              end
+      if links.length == 1 # If there's only one match then use any text that was supplied
+        link_to_brick(text || links.first.last.join('/'), links.first.first, **kwargs)
+      else
+        links.map { |k, v| link_to_brick(v.join('/'), v, **kwargs) }.join(' &nbsp; ').html_safe
+      end
+    end
+  end # link_to_brick
+
+end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -138,15 +138,16 @@ module Brick
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
       # a different tenant.  If so then don't allow schema navigation.
-      chosen = if (is_show_schema_list = (apartment_multitenant && Apartment::Tenant.current == ::Brick.default_schema)) &&
+      chosen = if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' &&
+                  (current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2]
+                                                       .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first) &&
+                  (is_show_schema_list = (apartment_multitenant && current_schema == ::Brick.default_schema)) &&
                   (schema = (params ? params['_brick_schema'] : ::Brick.default_schema)) &&
                   ::Brick.db_schemas&.key?(schema)
                  Apartment::Tenant.switch!(schema)
                  schema
-               elsif ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-                 # Just return the current schema
-                 current_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-                 (current_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first
+               else
+                 current_schema # Just return the current schema
                end
       [chosen == ::Brick.default_schema ? nil : chosen, is_show_schema_list]
     end
@@ -1262,8 +1263,8 @@ module ActiveRecord
         # entry in your .select().
         # More information:  https://discuss.rubyonrails.org/t/includes-and-select-for-joined-data/81640
         def apply_column_aliases(relation)
-          used_cols = {}
           if (sel_vals = relation.select_values.map(&:to_s)).first == '_brick_eager_load'
+            used_cols = {}
             # Find and expand out all column names being used in select(...)
             new_select_values = sel_vals.each_with_object([]) do |col, s|
               next if col == '_brick_eager_load'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.97
+  version: 1.0.98
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-25 00:00:00.000000000 Z
+date: 2022-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -216,6 +216,7 @@ files:
 - lib/brick/frameworks/rails/controller.rb
 - lib/brick/frameworks/rails/crosstab.brk
 - lib/brick/frameworks/rails/engine.rb
+- lib/brick/frameworks/rails/form_tags.rb
 - lib/brick/frameworks/rspec.rb
 - lib/brick/join_array.rb
 - lib/brick/serializers/json.rb