brick 1.0.91 → 1.0.93

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81eaa518a99452286bdaf1e5ed33b83962ede9f9c6509f0b472fd0fe19a8eceb
-  data.tar.gz: 06f5653ce40eb6ee1568b380cf3063073ac7735add8aab6c5873a343e8018a70
+  metadata.gz: 8488acac0623c04f11e916c67303fd06d471154231c92613318cc7458fcfe23f
+  data.tar.gz: af566c853bb25e7497a6afbba539ad0d14ec23ad000c053e6dbdf757deefbaa0
 SHA512:
-  metadata.gz: 7e0a678885c927a7a80c8758d265c2ff351f67ea44e8e1b2c128e123df441f4f72a62f775b9785615eeacbdbff99427e9d1590890bdffd06165ae7b2339fe1af
-  data.tar.gz: 7bd3e424225e435bab4517fb14aeaa3ca128041a746aaf413ecdb17a771444c3413f058ff28cc5e303d074fdd7cc7d21ff66f842667c14226d1849e96d4b3a98
+  metadata.gz: d0d8428b6f80bf3a79abb16265fb8625404f92caf30034da94186a5c5982a78543f29e0a49cc0dc515eb8b6d6da24ccdd53e8d089c90dce46ce214ce5bee4339
+  data.tar.gz: 562bd7522f0f45843a89464645e1cc153e455e1e5b4e3dec5f1b38a8bfaefd8bd359a2538aa274b90b50353285d2175f315b7e304e54e60516a5ce2ed3b2fc7e

data/lib/brick/compatibility.rb

@@ -11,6 +11,7 @@ unless ActiveRecord.respond_to?(:version)
 end
 
 # ActiveSupport, ActionPack, and ActionView before 4.0 didn't have #version
+require 'active_support' # Needed for Rails 4.x
 unless ActiveSupport.respond_to?(:version)
   module ActiveSupport
     def self.version

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?
@@ -270,7 +255,7 @@ module ActiveRecord
 
     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,83 +392,10 @@ module ActiveRecord
   end
 
   class Relation
-    attr_reader :_brick_chains, :_arel_applied_aliases
-
-    # 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
-          (_brick_chains[table._arel_table_type] ||= []) << (alias_name || table.table_alias || table.name)
-        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!
-        # Spin up an empty set of Brick alias name chains at the start
-        @_brick_chains = {}
-        # The left side is the "FROM" table
-        names << (this_name = [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)])
-        # # Do not currently need the root "FROM" table in our list of chains
-        # (_brick_chains[this_name.first] ||= []) << this_name.last
-        # 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
+    # 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
 
     def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
@@ -501,13 +413,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
@@ -545,10 +460,20 @@ 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
-        chains = rel_dupe._brick_chains
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
         used_col_aliases = {} # Used to make sure there is not a name clash
@@ -569,7 +494,7 @@ module ActiveRecord
           key_alias = nil
           cc.first.each do |cc_part|
             dest_klass = cc_part[0..-2].inject(klass) { |kl, cc_part_term| kl.reflect_on_association(cc_part_term).klass }
-            tbl_name = (field_tbl_names[k][cc_part.last] ||= shift_or_first(chains[dest_klass])).split('.').last
+            tbl_name = rel_dupe.brick_links[cc_part[0..-2].map(&:to_s).join('.')]
             # Deal with the conflict if there are two parts in the custom column named the same,
             # "category.name" and "product.name" for instance will end up with aliases of "name"
             # and "product__name".
@@ -606,23 +531,18 @@ module ActiveRecord
 
         klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
-            next if chains[k1].nil?
+            next unless (tbl_name = rel_dupe.brick_links[v.first.to_s]&.split('.')&.last)
 
-            tbl_name = (field_tbl_names[v.first][k1] ||= shift_or_first(chains[k1])).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| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
-              # unless chains[sel_col.first]
-              #   puts 'You might have some bogus DSL in your brick.rb file'
-              #   next
-              # end
-              field_tbl_name = (field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])).split('.').last
+            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[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
+              is_xml = is_distinct && Brick.relations[field_tbl_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('__')}"
@@ -659,14 +579,9 @@ module ActiveRecord
           end
         end
         join_array.each do |assoc_name|
-          # %%% Need to support {user: :profile}
           next unless assoc_name.is_a?(Symbol)
 
-          table_alias = if (chain = chains[klass = reflect_on_association(assoc_name)&.klass])
-                          shift_or_first(chain)
-                        else
-                          klass.table_name # ActiveRecord < 4.2 can't (yet) use the cool chains thing
-                        end
+          table_alias = rel_dupe.brick_links[assoc_name.to_s]
           _assoc_names[assoc_name] = [table_alias, klass]
         end
       end
@@ -677,26 +592,47 @@ module ActiveRecord
                          # Build the chain of JOINs going to the final destination HMT table
                          # (Usually just one JOIN, but could be many.)
                          hmt_assoc = hm
-                         x = []
-                         x.unshift(hmt_assoc) while hmt_assoc.options[:through] && (hmt_assoc = klass.reflect_on_association(hmt_assoc.options[:through]))
-                         from_clause = +"#{x.first.table_name} br_t0"
-                         fk_col = x.shift.foreign_key
-                         link_back = [klass.primary_key] # %%% Inverse path back to the original object -- used to build out a link with a filter
+                         through_sources = []
+                         # %%% Inverse path back to the original object -- not yet used, but soon
+                         # will be leveraged in order to build links with multi-table-hop filters.
+                         link_back = []
+                         # Track polymorphic type field if necessary
+                         if hm.source_reflection.options[:as]
+                           poly_ft = [hm.source_reflection.inverse_of.foreign_type, hmt_assoc.source_reflection.class_name]
+                         end
+                         # link_back << hm.source_reflection.inverse_of.name
+                         while hmt_assoc.options[:through] && (hmt_assoc = klass.reflect_on_association(hmt_assoc.options[:through]))
+                           through_sources.unshift(hmt_assoc)
+                         end
+                         # Turn the last member of link_back into a foreign key
+                         link_back << hmt_assoc.source_reflection.foreign_key
+                         # If it's a HMT based on a HM -> HM, must JOIN the last table into the mix at the end
+                         through_sources.push(hm.source_reflection) unless hm.source_reflection.belongs_to?
+                         from_clause = +"#{through_sources.first.table_name} br_t0"
+                         fk_col = through_sources.shift.foreign_key
+
                          idx = 0
                          bail_out = nil
-                         x.map do |a|
+                         through_sources.map do |a|
                            from_clause << "\n LEFT OUTER JOIN #{a.table_name} br_t#{idx += 1} "
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
+                                            (nm = hmt_assoc.source_reflection.inverse_of&.name)
+                                            # binding.pry unless nm
+                                            link_back << nm
                                             "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
                                           elsif src_ref.options[:as]
                                             "ON br_t#{idx}.#{src_ref.type} = '#{src_ref.active_record.name}'" + # "polymorphable_type"
                                             " AND br_t#{idx}.#{src_ref.foreign_key} = br_t#{idx - 1}.id"
                                           elsif src_ref.options[:source_type]
-                                            print "Skipping #{hm.name} --HMT-> #{hm.source_reflection.name} as it uses source_type which is not supported"
+                                            print "Skipping #{hm.name} --HMT-> #{hm.source_reflection.name} as it uses source_type which is not yet supported"
                                             nix << k
                                             bail_out = true
                                             break
                                           else # Standard has_many
+                                            # binding.pry unless (
+                                            nm = hmt_assoc.source_reflection.inverse_of&.name
+                                            # )
+                                            link_back << nm # if nm
                                             "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
                                           end
                            link_back.unshift(a.source_reflection.name)
@@ -704,6 +640,7 @@ module ActiveRecord
                          end
                          next if bail_out
 
+                         # puts "LINK BACK! #{k} : #{hm.table_name} #{link_back.map(&:to_s).join('.')}"
                          # count_column is determined from the originating HMT member
                          if (src_ref = hm.source_reflection).nil?
                            puts "*** Warning:  Could not determine destination model for this HMT association in model #{klass.name}:\n  has_many :#{hm.name}, through: :#{hm.options[:through]}"
@@ -711,8 +648,10 @@ module ActiveRecord
                            nix << k
                            next
                          elsif src_ref.macro == :belongs_to # Traditional HMT using an associative table
+                           # binding.pry if link_back.length > 2
                            "br_t#{idx}.#{hm.foreign_key}"
                          else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
+                           # binding.pry if link_back.length > 2
                            "br_t#{idx}.#{src_ref.active_record.primary_key}"
                          end
                        else
@@ -772,17 +711,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
-            k1 = klass.reflect_on_association(v_parts.first)&.klass
-            tbl_name = (field_tbl_names[v_parts.first][k1] ||= shift_or_first(chains[k1])).split('.').last
-            s["#{tbl_name}.#{v_parts.last}"] = v.last
+            tbl_name = rel_dupe.brick_links[v_parts.first].split('.').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
@@ -1078,7 +1023,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
@@ -1129,6 +1075,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),
@@ -1150,11 +1097,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) })
@@ -1165,7 +1112,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?
@@ -1367,7 +1314,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)
@@ -1464,7 +1411,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'
@@ -1482,7 +1429,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 },
@@ -1584,7 +1531,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"
@@ -1597,7 +1543,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
@@ -1608,7 +1554,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
 
@@ -1647,7 +1593,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
 
@@ -1876,13 +1822,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
@@ -1905,24 +1860,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
@@ -1935,7 +1872,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
@@ -2086,16 +2023,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]))
@@ -2113,7 +2050,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
@@ -2124,7 +2061,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
@@ -2162,7 +2099,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("'", "''")}'"}#{"
@@ -2261,7 +2198,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] = {} }
 
@@ -2277,7 +2214,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
@@ -2352,7 +2289,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]
@@ -2411,7 +2348,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
@@ -2441,14 +2378,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)
@@ -2464,7 +2401,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
@@ -2483,7 +2420,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

@@ -192,13 +192,13 @@ 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
@@ -466,6 +466,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 +494,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 +506,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 +835,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>
@@ -954,10 +955,12 @@ erDiagram
              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?
              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 +977,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 +1022,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>
@@ -1068,7 +1071,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 +1102,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 +1414,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 = 91
+    TINY = 93
 
     # 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 ||= {}
@@ -1052,21 +1058,43 @@ 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
+  class ActiveRecord::Associations::JoinDependency
+    if JoinBase.instance_method(:initialize).arity == 2 # Older ActiveRecord 4.x?
+      def initialize(base, associations, joins)
+        @alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(base.connection, joins)
+        @alias_tracker.aliased_table_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
+        tree = self.class.make_tree associations
+
+        # Provide a way to find the original relation that this tree is being used for
+        # (so that we can maintain a list of links for all tables used in JOINs)
+        if (relation = associations.instance_variable_get(:@relation))
+          tree.instance_variable_set(:@relation, relation)
+        end
+
+        @join_root = JoinBase.new base, build(tree, base)
+        @join_root.children.each { |child| construct_tables! @join_root, child }
+      end
+
+    else # For ActiveRecord 5.0 - 7.1
+
+      def initialize(base, table, associations, join_type = nil)
+        tree = self.class.make_tree associations
+
+        # Provide a way to find the original relation that this tree is being used for
+        # (so that we can maintain a list of links for all tables used in JOINs)
+        if (relation = associations.instance_variable_get(:@relation))
+          tree.instance_variable_set(:@relation, relation)
         end
+
+        @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type if join_type
       end
+    end
+  end
 
+  # was:  ActiveRecord.version >= ::Gem::Version.new('3.2') &&
+  if ActiveRecord.version < ::Gem::Version.new('5.0')
+    module ActiveRecord
       # Final pieces for left_outer_joins support, which was derived from this commit:
       # https://github.com/rails/rails/commit/3f46ef1ddab87482b730a3f53987e04308783d8b
       module Associations
@@ -1151,13 +1179,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
@@ -1175,59 +1199,108 @@ if ActiveRecord.version < ::Gem::Version.new('5.2')
         end
       end
     end
+  end
+end
 
-    module Associations
-      # Specific to AR 4.2 - 5.1:
-      if Associations.const_defined?('JoinDependency') && JoinDependency.private_instance_methods.include?(:table_aliases_for)
-        class JoinDependency
-        private
+# 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
+
+    if private_instance_methods.include?(:build_join_query)
+      alias _brick_build_join_query build_join_query
+      def build_join_query(manager, buckets, *args)
+        # %%% Better way to bring relation into the mix
+        if (aj = buckets.fetch(:association_join, nil))
+          aj.instance_variable_set(:@relation, self)
+        end
 
-          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
+        _brick_build_join_query(manager, buckets, *args)
+      end
+
+    else
+
+      alias _brick_select_association_list select_association_list
+      def select_association_list(associations, stashed_joins = nil)
+        result = _brick_select_association_list(associations, stashed_joins)
+        result.instance_variable_set(:@relation, self)
+        result
+      end
+    end
+  end
+
+  # require 'active_record/associations/join_dependency'
+  module Associations
+    # For AR >= 4.2
+    if self.const_defined?('JoinDependency')
+      class JoinDependency
+      private
+
+        # %%% Pretty much have to flat-out replace this guy (I think anyway)
+        # Good with Rails 5.24 and 7 on this
+        def build(associations, base_klass, root = nil, path = '')
+          root ||= associations
+          associations.map do |name, right|
+            reflection = find_reflection base_klass, name
+            reflection.check_validity!
+            reflection.check_eager_loadable!
+
+            if reflection.polymorphic?
+              raise EagerLoadPolymorphicError.new(reflection)
             end
+
+            # %%% The path
+            link_path = path.blank? ? name.to_s : path + ".#{name}"
+            ja = JoinAssociation.new(reflection, build(right, reflection.klass, root, link_path))
+            ja.instance_variable_set(:@link_path, link_path) # Make note on the JoinAssociation of its AR path
+            ja.instance_variable_set(:@assocs, root)
+            ja
           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
+        if JoinDependency.private_instance_methods.include?(:table_aliases_for)
+          # No matter if it's older or newer Rails, now extend so that we can associate AR links to table_alias names
+          alias _brick_table_aliases_for table_aliases_for
+          def table_aliases_for(parent, node)
+            result = _brick_table_aliases_for(parent, node)
 
-              tables << alias_tracker.aliased_table_for(
-                (reflection.source_reflection || reflection).join_table,
-                table_alias_for(reflection, true)
-              )
+            # Capture the table alias name that was chosen
+            link_path = node.instance_variable_get(:@link_path)
+            if (relation = node.instance_variable_get(:@assocs)&.instance_variable_get(:@relation))
+              relation.brick_links[link_path] = result.first.table_alias || result.first.table_name
             end
-            tables
+
+            result
+          end
+        else # Same idea but for Rails 7
+          alias _brick_make_constraints make_constraints
+          def make_constraints(parent, child, join_type)
+            result = _brick_make_constraints(parent, child, join_type)
+
+            # Capture the table alias name that was chosen
+            link_path = child.instance_variable_get(:@link_path)
+            relation = child.instance_variable_get(:@assocs)&.instance_variable_get(:@relation)
+            # binding.pry if relation
+            relation.brick_links[link_path] = result.first.left.table_alias || result.first.left.table_name
+            result
           end
         end
       end
     end
-  end # module ActiveRecord
-  # rubocop:enable Style/CommentedKeyword
+  end
 end
 
 require 'brick/extensions'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.91
+  version: 1.0.93
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-09 00:00:00.000000000 Z
+date: 2022-11-21 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