brick 1.0.92 → 1.0.94

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bb6854dd2295476ae00996f23e801587869463aa7114d9240c0e97b1cce25b1
-  data.tar.gz: f174948106c6a06be049f8285fb3358813d09b9970ce484554ad3c86bc3cb8fb
+  metadata.gz: 4b4de74edca4a5dd2c7d57d23dda2aa4cbc966402db4f2d0490dfeb741224dd5
+  data.tar.gz: fe905ed82bf8ae8f249e5ce3fe1646cb6366caf3343086ea8ba597e51525f521
 SHA512:
-  metadata.gz: 9384ef5db0a03fcc8fda6a3ceafc763a468f88033420d785814d657303027593c7fef64770087975d73d4041f577864c1d934629cb50083fb93d2591f719f136
-  data.tar.gz: e2b3e21982b9a6d132a3d9d05041759e06a3ac3ffbfdf2ea3675ee0140150f2d33b6e60cbeb0033a7f7469bba227f198a6cc6a0ef34c229ba7a1132cd1175b0d
+  metadata.gz: 45d2dda76345ab043c4e62d92b5e12a466ffec892e1ce63b540bd6427fcecfa777739732754d554f78b5803599fca1390fa2d38cb8f0acd9b0ffd8e5c6dd34aa
+  data.tar.gz: 65b73535a5874fe5b3c46fec455fe62857259c7d56b68241a729f2c928a47e0fdcc71988a3b7ead506de717fae71932007855efaf18dd8866b920da2c6d5c779

data/lib/brick/extensions.rb

@@ -42,21 +42,6 @@
 # Dynamically create model or controller classes when needed
 # ==========================================================
 
-# By default all models indicate that they are not views
-module Arel
-  class Table
-    def _arel_table_type
-      # AR < 4.2 doesn't have type_caster at all, so rely on an instance variable getting set
-      # AR 4.2 - 5.1 have buggy type_caster entries for the root node
-      instance_variable_get(:@_arel_table_type) ||
-      # 5.2-7.0 does type_caster just fine, no bugs there, but the property with the type differs:
-      # 5.2 has "types" as public, 6.0 "types" as private, and >= 6.1 "klass" as private.
-      ((tc = send(:type_caster)) && tc.instance_variable_get(:@types)) ||
-      tc.send(:klass)
-    end
-  end
-end
-
 module ActiveRecord
   class Base
     def self.is_brick?
@@ -260,17 +245,20 @@ module ActiveRecord
     end
 
     def self.bt_link(assoc_name)
-      assoc_name = CGI.escapeHTML(assoc_name.to_s)
+      assoc_html_name = unless (assoc_name = assoc_name.to_s).camelize == name
+                          CGI.escapeHTML(assoc_name)
+                        end
       model_path = ::Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
+      model_path << "?#{self.inheritance_column}=#{self.name}" if self != base_class
       av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
       av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('7')
-      link = av_class.link_to(name, model_path)
-      table_name == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+      link = av_class.link_to(assoc_html_name ? name : assoc_name, model_path)
+      assoc_html_name ? "#{assoc_name}-#{link}".html_safe : link
     end
 
     def self._brick_index(mode = nil)
       tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
-      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == Apartment.default_schema
+      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
       tbl_parts.unshift(::Brick.config.path_prefix) if ::Brick.config.path_prefix
       index = tbl_parts.map(&:underscore).join('_')
       # Rails applies an _index suffix to that route when the resource name is singular
@@ -407,86 +395,12 @@ module ActiveRecord
   end
 
   class Relation
-    attr_reader :_arel_applied_aliases
-
-    # Links from ActiveRecord association pathing names over to real
-    # table correlation names built from AREL aliasing
+    # Links from ActiveRecord association pathing names over to real table correlation names
+    # that get chosen when the AREL AST tree is walked.
     def brick_links
       @brick_links ||= {}
     end
 
-    # CLASS STUFF
-    def _recurse_arel(piece, prefix = '')
-      names = []
-      # Our JOINs mashup of nested arrays and hashes
-      # binding.pry if defined?(@arel)
-      case piece
-      when Array
-        names += piece.inject([]) { |s, v| s + _recurse_arel(v, prefix) }
-      when Hash
-        names += piece.inject([]) do |s, v|
-          new_prefix = "#{prefix}#{v.first}_"
-          s << [v.last.shift, new_prefix]
-          s + _recurse_arel(v.last, new_prefix)
-        end
-
-      # ActiveRecord AREL objects
-      when Arel::Nodes::Join # INNER or OUTER JOIN
-        # rubocop:disable Style/IdenticalConditionalBranches
-        if piece.right.is_a?(Arel::Table) # Came in from AR < 3.2?
-          # Arel 2.x and older is a little curious because these JOINs work "back to front".
-          # The left side here is either another earlier JOIN, or at the end of the whole tree, it is
-          # the first table.
-          names += _recurse_arel(piece.left)
-          # The right side here at the top is the very last table, and anywhere else down the tree it is
-          # the later "JOIN" table of this pair.  (The table that comes after all the rest of the JOINs
-          # from the left side.)
-          names << [piece.right._arel_table_type, (piece.right.table_alias || piece.right.name)]
-        else # "Normal" setup, fed from a JoinSource which has an array of JOINs
-          # The left side is the "JOIN" table
-          names += _recurse_arel(table = piece.left)
-          # The expression on the right side is the "ON" clause
-          # on = piece.right.expr
-          # # Find the table which is not ourselves, and thus must be the "path" that led us here
-          # parent = piece.left == on.left.relation ? on.right.relation : on.left.relation
-          # binding.pry if piece.left.is_a?(Arel::Nodes::TableAlias)
-          if table.is_a?(Arel::Nodes::TableAlias)
-            @_arel_applied_aliases << (alias_name = table.right)
-            table = table.left
-          end
-        end
-        # rubocop:enable Style/IdenticalConditionalBranches
-      when Arel::Table # Table
-        names << [piece._arel_table_type, (piece.table_alias || piece.name)]
-      when Arel::Nodes::TableAlias # Alias
-        # Can get the real table name from:  self._recurse_arel(piece.left)
-        names << [piece.left._arel_table_type, piece.right.to_s] # This is simply a string; the alias name itself
-      when Arel::Nodes::JoinSource # Leaving this until the end because AR < 3.2 doesn't know at all about JoinSource!
-        # The left side is the "FROM" table
-        names << (this_name = [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)])
-        # The right side is an array of all JOINs
-        piece.right.each { |join| names << _recurse_arel(join) }
-      end
-      names
-    end
-
-    # INSTANCE STUFF
-    def _arel_alias_names
-      @_arel_applied_aliases = []
-      # %%% If with Rails 3.1 and older you get "NoMethodError: undefined method `eq' for nil:NilClass"
-      # when trying to call relation.arel, then somewhere along the line while navigating a has_many
-      # relationship it can't find the proper foreign key.
-      core = arel.ast.cores.first
-      # Accommodate AR < 3.2
-      if core.froms.is_a?(Arel::Table)
-        # All recent versions of AR have #source which brings up an Arel::Nodes::JoinSource
-        _recurse_arel(core.source)
-      else
-        # With AR < 3.2, "froms" brings up the top node, an Arel::Nodes::InnerJoin
-        _recurse_arel(core.froms)
-      end
-    end
-
     def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
       is_add_bts = is_add_hms = true
 
@@ -502,13 +416,16 @@ module ActiveRecord
       params.each do |k, v|
         next if ['_brick_schema', '_brick_order', 'controller', 'action'].include?(k)
 
-        case (ks = k.split('.')).length
+        if (where_col = (ks = k.split('.')).last)[-1] == '!'
+          where_col = where_col[0..-2]
+        end
+        case ks.length
         when 1
-          next unless klass.column_names.any?(k) || klass._brick_get_fks.include?(k)
+          next unless klass.column_names.any?(where_col) || klass._brick_get_fks.include?(where_col)
         when 2
           assoc_name = ks.first.to_sym
           # Make sure it's a good association name and that the model has that column name
-          next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(ks.last)
+          next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(where_col)
 
           join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
           is_distinct = true
@@ -546,8 +463,19 @@ module ActiveRecord
 
       if join_array.present?
         left_outer_joins!(join_array)
-        # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
-        (rel_dupe = dup)._arel_alias_names
+        # 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] = {} }
@@ -609,15 +537,15 @@ module ActiveRecord
             next unless (tbl_name = rel_dupe.brick_links[v.first.to_s]&.split('.')&.last)
 
             # If it's Oracle, quote any AREL aliases that had been applied
-            tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.include?(tbl_name)
+            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
               # If it's Oracle, quote any AREL aliases that had been applied
-              field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.include?(field_tbl_name)
+              field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe.brick_links.values.include?(field_tbl_name)
 
               # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
-              is_xml = is_distinct && Brick.relations[field_tbl_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
+              is_xml = is_distinct && Brick.relations[k1.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
               # If it's not unique then also include the belongs_to association name before the column name
               if used_col_aliases.key?(col_alias = "br_fk_#{v.first}__#{sel_col.last}")
                 col_alias = "br_fk_#{v.first}__#{v1[idx][-2..-1].map(&:to_s).join('__')}"
@@ -786,16 +714,23 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
 
       unless wheres.empty?
         # Rewrite the wheres to reference table and correlation names built out by AREL
+        where_nots = {}
         wheres2 = wheres.each_with_object({}) do |v, s|
+          is_not = if v.first[-1] == '!'
+                     v[0] = v[0][0..-2] # Take off ending ! from column name
+                   end
           if (v_parts = v.first.split('.')).length == 1
-            s[v.first] = v.last
+            (is_not ? where_nots : s)[v.first] = v.last
           else
             tbl_name = rel_dupe.brick_links[v_parts.first].split('.').last
-            s["#{tbl_name}.#{v_parts.last}"] = v.last
+            (is_not ? where_nots : s)["#{tbl_name}.#{v_parts.last}"] = v.last
           end
         end
         if respond_to?(:where!)
-          where!(wheres2)
+          where!(wheres2) if wheres2.present?
+          if where_nots.present?
+            self.where_clause += WhereClause.new(predicate_builder.build_from_hash(where_nots)).invert
+          end
         else # AR < 4.0
           self.where_values << build_where(wheres2)
         end
@@ -1091,7 +1026,8 @@ Module.class_exec do
                                    (table_name = singular_table_name.pluralize),
                                    ::Brick.is_oracle ? class_name.upcase : class_name,
                                    (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas&.include?(s) }&.camelize ||
-                                  (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
+                                  (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name) ||
+                                  (::Brick.config.table_name_prefixes&.values.include?(class_name) && class_name))
                return self.const_get(schema_name) if self.const_defined?(schema_name)
 
                # Build out a module for the schema if it's namespaced
@@ -1142,6 +1078,7 @@ class Object
   private
 
     def build_model(relations, base_module, base_name, class_name, inheritable_name = nil)
+      tnp = ::Brick.config.table_name_prefixes&.find { |p| p.last == base_module.name }&.first
       if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
          base_module != Object # ... or otherwise already in some namespace?
         schema_name = [(singular_schema_name = base_name.underscore),
@@ -1163,11 +1100,11 @@ class Object
         table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
                        base_model.table_name
                      else
-                       ActiveSupport::Inflector.pluralize(singular_table_name)
+                       "#{tnp}#{ActiveSupport::Inflector.pluralize(singular_table_name)}"
                      end
         if ::Brick.apartment_multitenant &&
            Apartment.excluded_models.include?(table_name.singularize.camelize)
-          schema_name = Apartment.default_schema
+          schema_name = ::Brick.apartment_default_tenant
         end
         # Maybe, just maybe there's a database table that will satisfy this need
         if (matching = [table_name, singular_table_name, plural_class_name, model_name, table_name.titleize].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
@@ -1178,7 +1115,7 @@ class Object
 
     def build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
       if ::Brick.apartment_multitenant &&
-         schema_name == Apartment.default_schema
+         schema_name == ::Brick.apartment_default_tenant
         relation = relations["#{schema_name}.#{matching}"]
       end
       full_name = if relation || schema_name.blank?
@@ -1380,7 +1317,7 @@ class Object
                   # If it's multitenant with something like:  public.____ ...
                   if (it_parts = inverse_table.split('.')).length > 1 &&
                      ::Brick.apartment_multitenant &&
-                     it_parts.first == Apartment.default_schema
+                     it_parts.first == ::Brick.apartment_default_tenant
                     it_parts.shift # ... then ditch the generic schema name
                   end
                   inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[inverse_table], inverse, it_parts.join('_').singularize)
@@ -1477,7 +1414,7 @@ class Object
             instance_variable_set(:@resources, ::Brick.get_status_of_resources)
           end
           self.define_method :orphans do
-            instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params)))
+            instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params).first))
           end
           return [new_controller_class, code + "end # BrickGem controller\n"]
         when 'BrickOpenapi'
@@ -1495,7 +1432,7 @@ class Object
               api_params = referrer_params&.to_h
             end
           end
-          ::Brick.set_db_schema(params || api_params)
+          _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 },
@@ -1597,7 +1534,6 @@ class Object
         end
 
         unless is_openapi
-          ::Brick.set_db_schema
           _, 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"
@@ -1610,7 +1546,7 @@ class Object
             code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
             code << "  end\n"
             self.define_method :show do
-              ::Brick.set_db_schema(params)
+              _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
               instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
             end
           end
@@ -1621,7 +1557,7 @@ class Object
           code << "    @#{singular_table_name} = #{model.name}.new\n"
           code << "  end\n"
           self.define_method :new do
-            ::Brick.set_db_schema(params)
+            _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
             instance_variable_set("@#{singular_table_name}".to_sym, model.new)
           end
 
@@ -1660,7 +1596,7 @@ class Object
             code << "    #{find_by_name}\n"
             code << "  end\n"
             self.define_method :edit do
-              ::Brick.set_db_schema(params)
+              _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
               instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
             end
 
@@ -1889,13 +1825,22 @@ end.class_exec do
           s[row.first] = { dt: row.last } unless ['information_schema', 'pg_catalog', 'pg_toast', 'heroku_ext',
                                                   'INFORMATION_SCHEMA', 'sys'].include?(row.first)
         end
-        if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
-           (sta = multitenancy[:schema_to_analyse]) != 'public') &&
-           ::Brick.db_schemas.key?(sta)
-          # Take note of the current schema so we can go back to it at the end of all this
-          orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-          ::Brick.default_schema = schema = sta
-          ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
+        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) })
+            ::Brick.default_schema = ::Brick.apartment_default_tenant
+            schema = possible_schema
+            orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
+            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
+          elsif Rails.env == 'test' # When testing, just find the most recently-created schema
+            ::Brick.default_schema = schema = ::Brick.db_schemas.to_a.sort { |a, b| b.last[:dt] <=> a.last[:dt] }.first.first
+            puts "While running tests, had noticed in the brick.rb initializer that the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reading table structure from the most recently-created schema, #{schema}."
+            orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
+            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
+          else
+            puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
+          end
         end
       when 'Mysql2'
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
@@ -1918,24 +1863,6 @@ end.class_exec do
 
       ::Brick.db_schemas ||= {}
 
-      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        if (possible_schemas = ::Brick.config.schema_behavior&.[](:multitenant)&.[](: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) })
-            ::Brick.default_schema = schema = possible_schema
-            orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
-          elsif Rails.env == 'test' # When testing, just find the most recently-created schema
-            ::Brick.default_schema = schema = ::Brick.db_schemas.to_a.sort { |a, b| b.last[:dt] <=> a.last[:dt] }.first.first
-            puts "While running tests, had noticed in the brick.rb initializer that the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reading table structure from the most recently-created schema, #{schema}."
-            orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-            ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
-          else
-            puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
-          end
-        end
-      end
-
       # %%% Retrieve internal ActiveRecord table names like this:
       # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
       # For if it's not SQLite -- so this is the Postgres and MySQL version
@@ -1948,7 +1875,7 @@ end.class_exec do
           # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
           # is the default schema, usually 'public'.
           schema_name = if ::Brick.config.schema_behavior[:multitenant]
-                          Apartment.default_schema if apartment_excluded&.include?(r['relation_name'].singularize.camelize)
+                          ::Brick.apartment_default_tenant if apartment_excluded&.include?(r['relation_name'].singularize.camelize)
                         elsif ![schema, 'public'].include?(r['schema'])
                           r['schema']
                         end
@@ -2099,16 +2026,16 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         fk = fk.values unless fk.is_a?(Array)
         # Multitenancy makes things a little more general overall, except for non-tenanted tables
         if apartment_excluded&.include?(::Brick.namify(fk[1]).singularize.camelize)
-          fk[0] = Apartment.default_schema
-        elsif (is_postgres && (fk[0] == 'public' || (is_multitenant && fk[0] == schema))) ||
+          fk[0] = ::Brick.apartment_default_tenant
+        elsif (is_postgres && (fk[0] == 'public' || (multitenancy && fk[0] == schema))) ||
               (::Brick.is_oracle && fk[0] == schema) ||
               (is_mssql && fk[0] == 'dbo') ||
               (!is_postgres && !::Brick.is_oracle && !is_mssql && ['mysql', 'performance_schema', 'sys'].exclude?(fk[0]))
           fk[0] = nil
         end
         if apartment_excluded&.include?(fk[4].singularize.camelize)
-          fk[3] = Apartment.default_schema
-        elsif (is_postgres && (fk[3] == 'public' || (is_multitenant && fk[3] == schema))) ||
+          fk[3] = ::Brick.apartment_default_tenant
+        elsif (is_postgres && (fk[3] == 'public' || (multitenancy && fk[3] == schema))) ||
               (::Brick.is_oracle && fk[3] == schema) ||
               (is_mssql && fk[3] == 'dbo') ||
               (!is_postgres && !::Brick.is_oracle && !is_mssql && ['mysql', 'performance_schema', 'sys'].exclude?(fk[3]))
@@ -2126,7 +2053,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     relations.each do |k, v|
       rel_name = k.split('.').map { |rel_part| ::Brick.namify(rel_part, :underscore) }
       schema_names = rel_name[0..-2]
-      schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == Apartment.default_schema
+      schema_names.shift if ::Brick.apartment_multitenant && schema_names.first == ::Brick.apartment_default_tenant
       v[:schema] = schema_names.join('.') unless schema_names.empty?
       # %%% If more than one schema has the same table name, will need to add a schema name prefix to have uniqueness
       v[:resource] = rel_name.last
@@ -2137,7 +2064,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
     end
     ::Brick.load_additional_references if initializer_loaded
 
-    if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'heroku_ext']).first)
+    if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'pg_toast', 'heroku_ext']).first)
       puts "Now switching back to \"#{orig_schema}\" schema."
       ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", orig_schema)
     end
@@ -2175,7 +2102,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         AND kcu.column_name = c.column_name#{"
     --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}
     WHERE t.table_schema #{is_postgres || is_mssql ?
-        "NOT IN ('information_schema', 'pg_catalog',
+        "NOT IN ('information_schema', 'pg_catalog', 'pg_toast', 'heroku_ext',
                  'INFORMATION_SCHEMA', 'sys')"
         :
         "= '#{ActiveRecord::Base.connection.current_database.tr("'", "''")}'"}#{"
@@ -2274,7 +2201,7 @@ module Brick
       for_tbl = fk[1]
       fk_namified = ::Brick.namify(fk[1])
       apartment = Object.const_defined?('Apartment') && Apartment
-      fk[0] = Apartment.default_schema if apartment && apartment.excluded_models.include?(fk_namified.singularize.camelize)
+      fk[0] = ::Brick.apartment_default_tenant if apartment && apartment.excluded_models.include?(fk_namified.singularize.camelize)
       fk[1] = "#{fk[0]}.#{fk[1]}" if fk[0] # && fk[0] != ::Brick.default_schema
       bts = (relation = relations.fetch(fk[1], nil))&.fetch(:fks) { relation[:fks] = {} }
 
@@ -2290,7 +2217,7 @@ module Brick
                                       # If Apartment gem lists the primary table as being associated with a non-tenanted model
                                       # then use 'public' schema for the primary table
                                       if apartment && apartment&.excluded_models.include?(fk[4].singularize.camelize)
-                                        fk[3] = Apartment.default_schema
+                                        fk[3] = ::Brick.apartment_default_tenant
                                         true
                                       end
                                     else
@@ -2365,7 +2292,7 @@ module Brick
         end
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
       else
-        inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && apartment && fk[0] == Apartment.default_schema
+        inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && apartment && fk[0] == ::Brick.apartment_default_tenant
                     for_tbl
                   else
                     fk[1]
@@ -2386,7 +2313,7 @@ module Brick
       rails_root = ::Rails.root.to_s
       migrations = if Dir.exist?(mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{rails_root}/db/migrate")
                      Dir["#{mig_path}/**/*.rb"].each_with_object(Hash.new { |h, k| h[k] = [] }) do |v, s|
-                       File.read(v).split("\n").each do |line|
+                       File.read(v).split("\n").each_with_index do |line, line_idx|
                          # For all non-commented lines, look for any that have "create_table", "alter_table", or "drop_table"
                          if !line.lstrip.start_with?('#') &&
                             (idx = (line.index('create_table ') || line.index('create_table('))&.+(13)) ||
@@ -2394,8 +2321,9 @@ module Brick
                             (idx = (line.index('drop_table ') || line.index('drop_table('))&.+(11))
                            tbl = line[idx..-1].match(/([:'"\w\.]+)/)&.captures&.first
                            if tbl
-                             s[tbl.tr(':\'"', '').pluralize] << v
-                             break
+                             v = v[(rails_root.length)..-1] if v.start_with?(rails_root)
+                             v = v[1..-1] if v.start_with?('/')
+                             s[tbl.tr(':\'"', '').pluralize] << [v, line_idx + 1]
                            end
                          end
                        end
@@ -2424,7 +2352,7 @@ module Brick
                end
       ::Brick.relations.keys.map do |v|
         tbl_parts = v.split('.')
-        tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == Apartment.default_schema
+        tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
         res = tbl_parts.join('.')
         [v, (model = models[res])&.last&.table_name, migrations&.fetch(res, nil), model&.first]
       end
@@ -2454,14 +2382,14 @@ module Brick
 
     # Locate orphaned records
     def find_orphans(multi_schema)
-      is_default_schema = multi_schema&.==(Apartment.default_schema)
+      is_default_schema = multi_schema&.==(::Brick.apartment_default_tenant)
       relations.each_with_object([]) do |v, s|
         frn_tbl = v.first
         next if (relation = v.last).key?(:isView) || config.exclude_tables.include?(frn_tbl) ||
                 !(for_pk = (relation[:pkey].values.first&.first))
 
         is_default_frn_schema = !is_default_schema && multi_schema &&
-                                ((frn_parts = frn_tbl.split('.')).length > 1 && frn_parts.first)&.==(Apartment.default_schema)
+                                ((frn_parts = frn_tbl.split('.')).length > 1 && frn_parts.first)&.==(::Brick.apartment_default_tenant)
         relation[:fks].select { |_k, assoc| assoc[:is_bt] }.each do |_k, bt|
           begin
             if bt.key?(:polymorphic)
@@ -2477,7 +2405,7 @@ module Brick
                 # Skip if database is multitenant, we're not focused on "public", and the foreign and primary tables
                 # are both in the "public" schema
                 next if is_default_frn_schema &&
-                        ((pri_parts = pri_tbl&.split('.'))&.length > 1 && pri_parts.first)&.==(Apartment.default_schema)
+                        ((pri_parts = pri_tbl&.split('.'))&.length > 1 && pri_parts.first)&.==(::Brick.apartment_default_tenant)
 
                 selects << "SELECT '#{pri_tbl}' AS pri_tbl, frn.#{fk_type_col} AS pri_type, frn.#{fk_id_col} AS pri_id, frn.#{for_pk} AS frn_id
                 FROM #{frn_tbl} AS frn
@@ -2496,7 +2424,7 @@ module Brick
               # are both in the "public" schema
               pri_tbl = bt.key?(:inverse_table) && bt[:inverse_table]
               next if is_default_frn_schema &&
-                      ((pri_parts = pri_tbl&.split('.'))&.length > 1 && pri_parts.first)&.==(Apartment.default_schema)
+                      ((pri_parts = pri_tbl&.split('.'))&.length > 1 && pri_parts.first)&.==(::Brick.apartment_default_tenant)
 
               pri_pk = relations[pri_tbl].fetch(:pkey, nil)&.values&.first&.first ||
                        _class_pk(pri_tbl, multi_schema)

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

@@ -141,10 +141,10 @@ module Brick
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :belongs_to
-                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
-                                          else
+                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :has_many
                                             source.inverse_of&.name # For HM -> HM style HMT
+                                          else # belongs_to or has_one
+                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
                                           end
                                  # If there is no inverse available for the source belongs_to association, make one based on the class name
                                  unless tbl_nm
@@ -192,18 +192,17 @@ module Brick
                 end
               end
 
-              apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
-              schema_options = if ::Brick.apartment_multitenant &&
-                                  (cur_schema = Apartment::Tenant.current) != apartment_default_schema
-                                 "<option selected value=\"#{cur_schema}\">#{cur_schema}</option>"
-                               else
-                                 ::Brick.db_schemas.keys.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }
-                               end.html_safe
+              apartment_default_schema = ::Brick.apartment_multitenant && ::Brick.apartment_default_tenant
+              if ::Brick.apartment_multitenant && ::Brick.db_schemas.length > 1
+                schema_options = +'<select id="schema"><% if @_is_show_schema_list %>'
+                ::Brick.db_schemas.keys.each { |v| schema_options << "\n  <option value=\"#{v}\">#{v}</option>" }
+                schema_options << "\n<% else %><option selected value=\"#{Apartment::Tenant.current}\">#{Apartment::Tenant.current}</option>\n"
+                schema_options << '<% end %></select>'
+              end
               # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
               # environment or whatever, then get either the controllers or routes list instead
               prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
-                                binding.pry if tbl.is_a?(Symbol)
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
                                   tbl = tbl_parts.last
                                 end
@@ -466,6 +465,22 @@ var #{table_name}HtColumns;
 // This PageTransitionEvent fires when the page first loads, as well as after any other history
 // transition such as when using the browser's Back and Forward buttons.
 window.addEventListener(\"pageshow\", function() {
+  if (tblSelect) { // Always present
+    var i = #{::Brick.config.path_prefix ? '0' : 'schemaSelect ? 1 : 0'},
+        changeoutList = changeout(location.href);
+    for (; i < changeoutList.length; ++i) {
+      tblSelect.value = changeoutList[i];
+      if (tblSelect.value !== \"\") break;
+    }
+
+    tblSelect.addEventListener(\"change\", function () {
+      var lhr = changeout(location.href, null, this.value);
+      if (brickSchema)
+        lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
+      location.href = lhr;
+    });
+  }
+
   if (schemaSelect && schemaSelect.options.length > 1) { // First drop-down is only present if multitenant
     brickSchema = changeout(location.href, \"_brick_schema\");
     if (brickSchema) {
@@ -478,6 +493,7 @@ window.addEventListener(\"pageshow\", function() {
       location.href = changeout(location.href, \"_brick_schema\", this.value, tblSelect.value);
     });
   }
+
   [... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
     if (brickSchema)
       form.action = changeout(form.action, \"_brick_schema\", brickSchema);
@@ -489,22 +505,6 @@ window.addEventListener(\"pageshow\", function() {
       return true;
     });
   });
-
-  if (tblSelect) { // Always present
-    var i = #{::Brick.config.path_prefix ? '0' : 'schemaSelect ? 1 : 0'},
-        changeoutList = changeout(location.href);
-    for (; i < changeoutList.length; ++i) {
-      tblSelect.value = changeoutList[i];
-      if (tblSelect.value !== \"\") break;
-    }
-
-    tblSelect.addEventListener(\"change\", function () {
-      var lhr = changeout(location.href, null, this.value);
-      if (brickSchema)
-        lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
-      location.href = lhr;
-    });
-  }
 });
 
 // Add \"Are you sure?\" behaviour to any data-confirm buttons out there
@@ -834,7 +834,7 @@ erDiagram
 </head>
 <body>
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
+#{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><tr>
   <td><h1>#{model_name}</h1></td>
@@ -910,7 +910,9 @@ erDiagram
      end
      unless @_brick_sequence # If no sequence is defined, start with all inclusions
        cust_cols = #{model_name}._br_cust_cols
-       @_brick_sequence = col_keys + cust_cols.keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
+       # 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|
@@ -927,8 +929,12 @@ erDiagram
        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 (cc = cust_cols.key?(col_name)) # Custom column
+       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
@@ -946,18 +952,22 @@ erDiagram
     <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])%>><%
+      <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
-             # binding.pry if @_brick_bt_descrip[bt.first][bt[1].first.first].nil?
+           else # BT or HOT
              bt_class = bt[1].first.first
              descrips = @_brick_bt_descrip[bt.first][bt_class]
-             bt_id_col = if descrips.length == 1
+             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]
                          else
                            descrips.last
@@ -974,16 +984,16 @@ erDiagram
            if hms_col.length == 1 %>
         <%=  hms_col.first %>
         <% else
-             klass = (col = cols[col_name])[1]
-             txt = if col[2] == 'HO'
-                     descrips = @_brick_bt_descrip[col_name.to_sym][klass]
-                     ho_txt = klass.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
-                     ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
-                     ho_id&.first ? link_to(ho_txt, send(\"#\{klass.base_class._brick_index(:singular)}_path\".to_sym, ho_id)) : ho_txt
-                   else
-                     \"#\{hms_col[1] || 'View'} #\{hms_col.first}\"
-                   end %>
-         <%= link_to txt, send(\"#\{klass._brick_index}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
+    %><%=    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
@@ -1019,7 +1029,7 @@ erDiagram
 # Easily could be multiple files involved (STI for instance)
 +"#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
+#{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Status</h1>
 <table id=\"status\" class=\"shadow\"><thead><tr>
@@ -1038,7 +1048,7 @@ erDiagram
   %>
   <tr>
   <td><%= begin
-            kls = Object.const_get(::Brick.relations[r[0]].fetch(:class_name, nil))
+            kls = Object.const_get(::Brick.relations.fetch(r[0], nil)&.fetch(:class_name, nil))
           rescue
           end
           kls ? link_to(r[0], send(\"#\{kls._brick_index}_path\".to_sym)) : r[0] %></td>
@@ -1048,8 +1058,9 @@ erDiagram
            ' class=\"dimmed\"'
          end&.html_safe %>><%= # Table
           r[1] %></td>
-  <td<%= ' class=\"dimmed\"'.html_safe unless r[2] %>><%= # Migration
-          r[2]&.join('<br>')&.html_safe %></td>
+  <td<%= lines = r[2]&.map { |line| \"#\{line.first}:#\{line.last}\" }
+         ' class=\"dimmed\"'.html_safe unless r[2] %>><%= # Migration
+          lines&.join('<br>')&.html_safe %></td>
   <td<%= ' class=\"dimmed\"'.html_safe unless r[3] %>><%= # Model
           r[3] %></td>
   <td<%= ' class=\"dimmed\"'.html_safe unless r[4] %>><%= # Route
@@ -1068,7 +1079,7 @@ erDiagram
                          if is_orphans
 +"#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
+#{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Orphans<%= \" for #\{}\" if false %></h1>
 <% @orphans.each do |o|
@@ -1099,7 +1110,7 @@ erDiagram
 </svg>
 
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
+#{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1><%= page_title %></h1><%
 if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
@@ -1411,9 +1422,26 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
               # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
               keys = options.has_key?(:locals) ? options[:locals].keys : []
               handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')
-              ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
+              ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys).tap do |t|
+                t.instance_variable_set(:@is_brick, true)
+              end
             end
-          end
+          end # LookupContext
+
+          # For any auto-generated template, if multitenancy is active via some flavour of an Apartment gem, switch back to the default tenant.
+          # (Underlying reason -- ros-apartment can hold on to a selected tenant between requests when there is no elevator middleware.)
+          ActionView::TemplateRenderer.class_exec do
+            private
+
+              alias _brick_render_template render_template
+              def render_template(view, template, *args)
+                result = _brick_render_template(view, template, *args)
+                if template.instance_variable_get(:@is_brick)
+                  Apartment::Tenant.switch!(::Brick.apartment_default_tenant) if ::Brick.apartment_multitenant
+                end
+                result
+              end
+          end # TemplateRenderer
         end
 
         if ::Brick.enable_routes?

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -136,17 +136,19 @@ module Brick
     attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading, :auto_models
 
     def set_db_schema(params = nil)
-      schema = (params ? params['_brick_schema'] : ::Brick.default_schema)
-      chosen = if schema && ::Brick.db_schemas&.key?(schema)
-        ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
-        schema
-      elsif ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        # Just return the current schema
-        orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
-        # ::Brick.apartment_multitenant && tbl_parts.first == Apartment.default_schema
-        (orig_schema - ['pg_catalog']).first
-      end
-      chosen == ::Brick.default_schema ? nil : chosen
+      # 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)) &&
+                  (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
+               end
+      [chosen == ::Brick.default_schema ? nil : chosen, is_show_schema_list]
     end
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
@@ -162,6 +164,10 @@ module Brick
       @apartment_multitenant
     end
 
+    def apartment_default_tenant
+      Apartment.default_tenant || 'public'
+    end
+
     # If multitenancy is enabled, a list of non-tenanted "global" models
     def non_tenanted_models
       @pending_models ||= {}
@@ -205,12 +211,13 @@ module Brick
           else
             s.first[a.foreign_key.to_s] = [a.name, a.klass]
           end
-        else # This gets has_many as well as has_one and has_many :through
-          if through
+        else # This gets all forms of has_many and has_one
+          if through # has_many :through or has_one :through
             is_invalid_source = nil
             begin
-              if a.through_reflection&.belongs_to?
-                puts "WARNING:  HMT relationship :#{a.name} in model #{model.name} tries to go through belongs_to association :#{through}.  This is not possible."
+              if a.through_reflection.macro != :has_many # This HM goes through either a belongs_to or a has_one, so essentially a HOT?
+                # Treat it like a belongs_to - just keyed on the association name instead of a foreign_key
+                s.first[a.name] = [a.name, a.klass]
                 next
               elsif !a.source_reflection # Had considered:  a.active_record.reflect_on_association(a.source_reflection_name).nil?
                 is_invalid_source = true
@@ -1086,21 +1093,9 @@ ActiveSupport.on_load(:active_record) do
     end
   end
 
-  # First part of arel_table_type stuff:
-  # ------------------------------------
-  # (more found below)
   # was:  ActiveRecord.version >= ::Gem::Version.new('3.2') &&
   if ActiveRecord.version < ::Gem::Version.new('5.0')
-    # Used by Util#_arel_table_type
     module ActiveRecord
-      class Base
-        def self.arel_table
-          @arel_table ||= Arel::Table.new(table_name, arel_engine).tap do |x|
-            x.instance_variable_set(:@_arel_table_type, self)
-          end
-        end
-      end
-
       # Final pieces for left_outer_joins support, which was derived from this commit:
       # https://github.com/rails/rails/commit/3f46ef1ddab87482b730a3f53987e04308783d8b
       module Associations
@@ -1185,13 +1180,9 @@ if is_postgres && ActiveRecord.version < ::Gem::Version.new('5.0') # Was:  && Ob
   PGError = PG::Error
 end
 
-# More arel_table_type stuff:
-# ---------------------------
 if ActiveRecord.version < ::Gem::Version.new('5.2')
   # Specifically for AR 3.1 and 3.2 to avoid:  "undefined method `delegate' for ActiveRecord::Reflection::ThroughReflection:Class"
   require 'active_support/core_ext/module/delegation' if ActiveRecord.version < ::Gem::Version.new('4.0')
-  # Used by Util#_arel_table_type
-  # rubocop:disable Style/CommentedKeyword
   module ActiveRecord
     module Reflection
       # AR < 4.0 doesn't know about join_table and derive_join_table
@@ -1209,61 +1200,23 @@ if ActiveRecord.version < ::Gem::Version.new('5.2')
         end
       end
     end
-
-    module Associations
-      # Specific to AR 4.2 - 5.1:
-      if self.const_defined?('JoinDependency') && JoinDependency.private_instance_methods.include?(:table_aliases_for)
-        class JoinDependency
-        private
-
-          if ActiveRecord.version < ::Gem::Version.new('5.1') # 4.2 or 5.0
-            def table_aliases_for(parent, node)
-              node.reflection.chain.map do |reflection|
-                alias_tracker.aliased_table_for(
-                  reflection.table_name,
-                  table_alias_for(reflection, parent, reflection != node.reflection)
-                ).tap do |x|
-                  # %%% Specific only to Rails 4.2 (and maybe 4.1?)
-                  x = x.left if x.is_a?(Arel::Nodes::TableAlias)
-                  y = reflection.chain.find { |c| c.table_name == x.name }
-                  x.instance_variable_set(:@_arel_table_type, y.klass)
-                end
-              end
-            end
-          end
-        end
-      elsif Associations.const_defined?('JoinHelper') && JoinHelper.private_instance_methods.include?(:construct_tables)
-        module JoinHelper
-        private
-
-          # AR > 3.0 and < 4.2 (%%% maybe only < 4.1?) uses construct_tables like this:
-          def construct_tables
-            tables = []
-            chain.each do |reflection|
-              tables << alias_tracker.aliased_table_for(
-                table_name_for(reflection),
-                table_alias_for(reflection, reflection != self.reflection)
-              ).tap do |x|
-                x = x.left if x.is_a?(Arel::Nodes::TableAlias)
-                x.instance_variable_set(:@_arel_table_type, reflection.chain.find { |c| c.table_name == x.name }.klass)
-              end
-
-              next unless reflection.source_macro == :has_and_belongs_to_many
-
-              tables << alias_tracker.aliased_table_for(
-                (reflection.source_reflection || reflection).join_table,
-                table_alias_for(reflection, true)
-              )
-            end
-            tables
-          end
-        end
-      end
-    end
-  end # module ActiveRecord
-  # rubocop:enable Style/CommentedKeyword
+  end
 end
 
+# The "brick_links" patch -- this finds how every AR chain of association names
+# relates back to an exact table correlation name chosen by AREL when the AST tree is
+# walked.  For instance, from a Customer model there could be a join_tree such as
+# { orders: { line_items: :product} }, which would end up recording three entries, the
+# last of which for products would have a key of "orders.line_items.product" after
+# having gone through two HMs and one BT.  AREL would have chosen a correlation name of
+# "products", being able to use the same name as the table name because it's the first
+# time that table is used in this query.  But let's see what happens if each customer
+# also had a BT to a favourite product, referenced earlier in the join_tree like this:
+# [:favourite_product, orders: { line_items: :product}] -- then the second reference to
+# "products" would end up being called "products_line_items" in order to differentiate
+# it from the first reference, which would have already snagged the simpler name
+# "products".  It's essential that The Brick can find accurate correlation names when
+# there are multiple JOINs to the same table.
 module ActiveRecord
   module QueryMethods
   private
@@ -1290,7 +1243,7 @@ module ActiveRecord
     end
   end
 
-  # require 'activerecord/associations/join_dependency'
+  # require 'active_record/associations/join_dependency'
   module Associations
     # For AR >= 4.2
     if self.const_defined?('JoinDependency')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.92
+  version: 1.0.94
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-15 00:00:00.000000000 Z
+date: 2022-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -164,20 +164,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.42.0
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement