brick 1.0.77 → 1.0.78

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e113470d473585f716cfa5b835f503448a0d160b60de20f884bf3ce2cc14c08
-  data.tar.gz: 40064f980dd6893cb4e7e47861e00b184983d1a4bbc11b7cbd16fd6caddfab87
+  metadata.gz: 52f0716e20661f909922bdcddf3401b79b87c33c7b118d1581dfdf9861dd702c
+  data.tar.gz: 45323c512a8c7490b0ac715595ead6e6299d06a442b9c723318b90bcdce6106d
 SHA512:
-  metadata.gz: 4219dfee478a845a949b1ac9b03d0a135504723a892b571ca068af70c2b58ca52025f5e1f2fedb6a97a5b2dcd97280c5f54132b854e285e6daf7bc95d0c2d357
-  data.tar.gz: 67ae65b0de3801bbb2a1817d16b4023116ee7d41491b6d45927bd8197a8f800151f8ce79de34732a55f3dfcabbe301dc69b276899cfd544604d6a64e61220c99
+  metadata.gz: 2ef6ac2089e1150bc9c74c6625fc3e7627f5ee06a42d1a2d5fe43790d99156abacc27ba2e042044ee42171f352718d99ae8b468ec9dca4350cd6631bead51ce7
+  data.tar.gz: 8c4da365eb99677930a9f35f0cd5981b91adc790a13ecf55b5369da03fdf1592cccd01f911457cf204aa8769767d5a8537d856ff7080dec75543524b3e680904

data/lib/brick/extensions.rb

@@ -258,7 +258,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.first == Apartment.default_schema
+      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == Apartment.default_schema
       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
@@ -555,7 +555,10 @@ module ActiveRecord
             tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.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|
-              # binding.pry if chains[sel_col.first].nil?
+              # 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
               # 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)
@@ -606,15 +609,42 @@ module ActiveRecord
         end
       end
       # Add derived table JOIN for the has_many counts
+      nix = []
       klass._br_hm_counts.each do |k, hm|
-        associative = nil
         count_column = if hm.options[:through]
-                         if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
-                           if hm.source_reflection.macro == :belongs_to # Traditional HMT using an associative table
-                             hm.foreign_key
-                           else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
-                             hm.source_reflection.active_record.primary_key
-                           end
+                         # Build the chain of JOINs going to the final destination HMT table
+                         # (Usually just one JOIN, but could be many.)
+                         x = [hmt_assoc = hm]
+                         x.unshift(hmt_assoc) while hmt_assoc.options[:through] && (hmt_assoc = klass.reflect_on_association(hmt_assoc.options[:through]))
+                         from_clause = +"#{x.first.klass.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
+                         idx = 0
+                         bail_out = nil
+                         x[0..-2].map do |a|
+                           from_clause << "\n LEFT OUTER JOIN #{a.klass.table_name} br_t#{idx += 1} "
+                           from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
+                                            "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"
+                                            nix << k
+                                            bail_out = true
+                                            break
+                                          else # Standard has_many
+                                            "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
+                                          end
+                           link_back.unshift(a.source_reflection.name)
+                           [a.klass.table_name, a.foreign_key, a.source_reflection.macro]
+                         end
+                         next if bail_out
+                         # count_column is determined from the last HMT member
+                         if (src_ref = x.last.source_reflection).macro == :belongs_to # Traditional HMT using an associative table
+                           "br_t#{idx}.#{x.last.foreign_key}"
+                         else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
+                           "br_t#{idx}.#{src_ref.active_record.primary_key}"
                          end
                        else
                          fk_col = hm.foreign_key
@@ -652,20 +682,38 @@ module ActiveRecord
           selects << poly_type
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
-        hm_table_name = if is_mysql
-                          "`#{associative&.table_name || hm.klass.table_name}`"
-                        elsif is_postgres || is_mssql
-                          "\"#{(associative&.table_name || hm.klass.table_name).gsub('.', '"."')}\""
-                        else
-                          associative&.table_name || hm.klass.table_name
-                        end
+        unless from_clause
+          hm_table_name = if is_mysql
+                            "`#{hm.klass.table_name}`"
+                          elsif is_postgres || is_mssql
+                            "\"#{(hm.klass.table_name).gsub('.', '"."')}\""
+                          else
+                            hm.klass.table_name
+                          end
+        end
         group_bys = ::Brick.is_oracle || is_mssql ? selects : (1..selects.length).to_a
         join_clause = "LEFT OUTER
-JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
-          }) AS c_t_ FROM #{hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
+JOIN (SELECT #{selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
+          }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
-      where!(wheres) unless wheres.empty?
+      while (n = nix.pop)
+        klass._br_hm_counts.delete(n)
+      end
+
+      unless wheres.empty?
+        # Rewrite the wheres to reference table and correlation names built out by AREL
+        wheres2 = wheres.each_with_object({}) do |v, s|
+          if (v_parts = v.first.split('.')).length == 1
+            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
+          end
+        end
+        where!(wheres2)
+      end
       # Must parse the order_by and see if there are any symbols which refer to BT associations
       # or custom columns as they must be expanded to find the corresponding b_r_model__column
       # or br_cc_column naming for each.
@@ -805,12 +853,30 @@ Module.class_exec do
     end
     base_module = if self < ActiveRecord::Migration || !self.name
                     brick_root || Object
-                  elsif (split_self_name || self.name.split('::')).length > 1
-                    return self._brick_const_missing(*args)
+                  elsif (split_self_name || self.name.split('::')).length > 1 # Classic mode
+                    begin
+                      return self._brick_const_missing(*args)
+
+                    rescue NameError # %%% Avoid the error "____ cannot be autoloaded from an anonymous class or module"
+                      return self.const_get(args.first) if self.const_defined?(args.first)
+
+                      # unless self == (prnt = (respond_to?(:parent) ? parent : module_parent))
+                      unless self == Object
+                        begin
+                          return Object._brick_const_missing(*args)
+
+                        rescue NameError
+                          return Object.const_get(args.first) if Object.const_defined?(args.first)
+
+                        end
+                      end
+                    end
+                    Object
                   else
                     self
                   end
-    desired_classname = (self == Object) ? requested : "#{name}::#{requested}"
+    # puts "#{self.name} - #{args.first}"
+    desired_classname = (self == Object || !name) ? requested : "#{name}::#{requested}"
     if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) && possible.name == desired_classname) ||
        # Try to require the respective Ruby file
        ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
@@ -822,9 +888,7 @@ Module.class_exec do
        # then return what we've found.
        (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
       if (!brick_root && (filename || possible.instance_of?(Class))) ||
-         (possible.instance_of?(Module) &&
-          ((possible.respond_to?(:module_parent) ? possible.module_parent : possible.parent) == self)
-         ) ||
+         (possible.instance_of?(Module) && possible.module_parent == self) ||
          (possible.instance_of?(Class) && possible == self) # Are we simply searching for ourselves?
         return possible
       end
@@ -881,9 +945,21 @@ Module.class_exec do
       base_module._brick_const_missing(*args)
     # elsif base_module != Object
     #   module_parent.const_missing(*args)
-    else
-      puts "MISSING! #{base_module.name} #{args.inspect} #{table_name}"
-      base_module._brick_const_missing(*args)
+    elsif Rails.respond_to?(:autoloaders) && # After finding nothing else, if Zeitwerk is enabled ...
+        (Rails::Autoloaders.respond_to?(:zeitwerk_enabled?) ? Rails::Autoloaders.zeitwerk_enabled? : true)
+      self._brick_const_missing(*args) # ... rely solely on Zeitwerk.
+    else # Classic mode
+      unless (found = base_module._brick_const_missing(*args))
+        puts "MISSING! #{base_module.name} #{args.inspect} #{table_name}"
+      end
+      found
+    end
+  end
+
+  # Support Rails < 6.0 which adds #parent instead of #module_parent
+  unless respond_to?(:module_parent)
+    def module_parent # Weirdly for Grape::API does NOT come in with the proper class, but some anonymous Class thing
+      parent
     end
   end
 end
@@ -940,9 +1016,7 @@ class Object
                                       schema_name
                                     else
                                       matching = "#{schema_name}.#{matching}"
-                                      # %%% Coming up with integers when tables are in schemas
-                                      # ::Brick.db_schemas[schema_name] ||= self.const_get(schema_name.camelize.to_sym)
-                                      self.const_get(schema_name.camelize)
+                                      (::Brick.db_schemas[schema_name] || {})[:class] ||= self.const_get(schema_name.camelize.to_sym)
                                     end
                     "#{schema_module&.name}::#{inheritable_name || model_name}"
                   end
@@ -952,10 +1026,10 @@ class Object
 
       # Are they trying to use a pluralised class name such as "Employees" instead of "Employee"?
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
-        unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.camelize}::")
-          puts "Warning: Class name for a model that references table \"#{matching
-               }\" should be \"#{ActiveSupport::Inflector.singularize(inheritable_name || model_name)}\"."
-        end
+        # unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.camelize}::")
+        #   puts "Warning: Class name for a model that references table \"#{matching
+        #        }\" should be \"#{ActiveSupport::Inflector.singularize(inheritable_name || model_name)}\"."
+        # end
         return
       end
 
@@ -1393,7 +1467,7 @@ class Object
           end
 
           if pk.present?
-            # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
+            # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.key?(schema)
             #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
             # end
 
@@ -1574,6 +1648,7 @@ module ActiveRecord::ConnectionHandling
     # return if ActiveRecord::Base.connection.current_database == 'postgres'
 
     initializer_loaded = false
+    orig_schema = nil
     if (relations = ::Brick.relations).empty?
       # If there's schema things configured then we only expect our initializer to be named exactly this
       if File.exist?(brick_initializer = ::Rails.root.join('config/initializers/brick.rb'))
@@ -1607,12 +1682,14 @@ module ActiveRecord::ConnectionHandling
                   [row['table_schema'], row['dt']]
                 end
           # Remove any system schemas
-          s[row.first] = row.last unless ['information_schema', 'pg_catalog', 'pg_toast',
-                                          'INFORMATION_SCHEMA', 'sys'].include?(row.first)
+          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.include?(sta)
+           ::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)
         end
@@ -1622,7 +1699,7 @@ module ActiveRecord::ConnectionHandling
         # ActiveRecord::Base.connection.current_database will be something like "XEPDB1"
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.raw_connection.username
         ::Brick.db_schemas = {}
-        ActiveRecord::Base.execute_sql("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = nil }
+        ActiveRecord::Base.execute_sql("SELECT username FROM sys.all_users WHERE ORACLE_MAINTAINED != 'Y'").each { |s| ::Brick.db_schemas[s.first] = {} }
       when 'SQLite'
         sql = "SELECT m.name AS relation_name, UPPER(m.type) AS table_type,
           p.name AS column_name, p.type AS data_type,
@@ -1641,10 +1718,12 @@ module ActiveRecord::ConnectionHandling
         if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
           if ::Brick.db_schemas.key?(possible_schema)
             ::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 <=> a.last }.first.first
-            puts "While running tests, had noticed that in the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\" which does not exist.  Reverting to instead use the most recently-created schema, #{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 a schema called \"#{possible_schema}\".  This schema does not exist. ***"
@@ -1848,6 +1927,11 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       v[:class_name] = (schema_names + [rel_name.last.singularize]).map(&:camelize).join('::')
     end
     ::Brick.load_additional_references if initializer_loaded
+
+    if orig_schema && (orig_schema = (orig_schema - ['pg_catalog', 'heroku_ext']).first)
+      puts "Now switching back to \"#{orig_schema}\" schema."
+      ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", orig_schema)
+    end
   end
 
   def retrieve_schema_and_tables(sql = nil, is_postgres = nil, is_mssql = nil, schema = nil)
@@ -2134,7 +2218,12 @@ module Brick
                    end
                  end
                end
-      ::Brick.relations.keys.map { |v| [(model = models[v])&.last, model&.last&.table_name, migrations&.fetch(v, nil), model&.first] }
+      ::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
+        res = tbl_parts.join('.')
+        [v, (model = models[res])&.last&.table_name, migrations&.fetch(res, nil), model&.first]
+      end
     end
 
     def ensure_unique(name, *sources)

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

@@ -125,8 +125,8 @@ module Brick
                               "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if (through = hm_assoc.options[:through])
-                                 # %%% How to deal with weird self_ref type has_many -> has_one polymorphic stuff?
-                                 #     (or perhaps we don't need to!)
+                                 next unless @_brick_model._br_hm_counts.key?(hm_assoc.name) # Skip any weird HMTs that go through a HM with a source_type
+
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
@@ -353,11 +353,8 @@ def hide_bcrypt(val, max_len = 200)
     '(hidden)'
   else
     if val.is_a?(String)
-      if val.length > max_len
-        val = val[0...max_len]
-        val << '...'
-      end
-      val.force_encoding('UTF-8') unless val.encoding.name == 'UTF-8'
+      val = \"#\{val[0...max_len]}...\" if val.length > max_len
+      val = val.dup.force_encoding('UTF-8') unless val.encoding.name == 'UTF-8'
     end
     val
   end
@@ -372,7 +369,7 @@ def display_value(col_type, val)
       if @is_mysql || @is_mssql
         # MySQL's \"Internal Geometry Format\" and MSSQL's Geography are like WKB, but with an initial 4 bytes that indicates the SRID.
         if (srid = val&.[](0..3)&.unpack('I'))
-          val = val.force_encoding('BINARY')[4..-1].bytes
+          val = val.dup.force_encoding('BINARY')[4..-1].bytes
 
           # MSSQL spatial bitwise flags, often 0C for a point:
           # xxxx xxx1 = HasZValues
@@ -409,9 +406,8 @@ def display_value(col_type, val)
   end
 end
 # Accommodate composite primary keys that include strings with forward-slash characters
-def slashify(val)
-  val = [val] unless val.is_a?(Array)
-  val.map { |val_part| val_part.is_a?(String) ? val_part.gsub('/', '^^sl^^') : val_part }
+def slashify(*vals)
+  vals.map { |val_part| val_part.is_a?(String) ? val_part.gsub('/', '^^sl^^') : val_part }
 end
 callbacks = {} %>"
 
@@ -673,7 +669,7 @@ erDiagram
               inline = case args.first
                        when 'index'
                          obj_pk = if pk&.is_a?(Array) # Composite primary key?
-                                    "[#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}]" unless pk.empty?
+                                    "#{pk.map { |pk_part| "#{obj_name}.#{pk_part}" }.join(', ')}" unless pk.empty?
                                   elsif pk
                                     "#{obj_name}.#{pk}"
                                   end
@@ -787,7 +783,7 @@ erDiagram
        origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
        if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| fk[:fk] == key_parts.last }) &&
           (obj = (destination = origin.reflect_on_association(destination_fk[:assoc_name])&.klass)&.find(id)) %>
-         <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination._brick_index\}_path\".to_sym, id) %></h3><%
+         <h3>for <%= link_to \"#{"#\{obj.brick_descrip\} (#\{destination.name\})\""}, send(\"#\{destination._brick_index(:singular)\}_path\".to_sym, id) %></h3><%
        end
      end %>
   (<%= link_to 'See all #{model_name.split('::').last.pluralize}', #{@_brick_model._brick_index}_path %>)
@@ -940,7 +936,11 @@ erDiagram
   @resources.each do |r|
   %>
   <tr>
-  <td><%= link_to(r[0], r[0] && send(\"#\{r[0]&._brick_index}_path\".to_sym)) %></td>
+  <td><%= begin
+            kls = Object.const_get(::Brick.relations[r[0]].fetch(:class_name, nil))
+          rescue
+          end
+          kls ? link_to(r[0], send(\"#\{kls._brick_index}_path\".to_sym)) : r[0] %></td>
   <td<%= if r[1]
            ' class=\"orphan\"' unless ::Brick.relations.key?(r[1])
          else
@@ -1277,6 +1277,9 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
   }
 });
 </script>"
+              # puts "==============="
+              # puts inline
+              # puts "==============="
               # 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')

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -126,10 +126,15 @@ module Brick
     attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading
 
     def set_db_schema(params = nil)
-      schema = (params ? params['_brick_schema'] : ::Brick.default_schema) || 'public'
-      if schema && ::Brick.db_schemas&.include?(schema)
+      schema = (params ? params['_brick_schema'] : ::Brick.default_schema)
+      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
     end
 
@@ -435,7 +440,7 @@ module Brick
           end
         end
         if (polys = ::Brick.config.polymorphics)
-          if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
+          if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.key?(schema)
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
           end
           missing_stis = {}
@@ -525,9 +530,9 @@ In config/initializers/brick.rb appropriate entries would look something like:
       abstract_ar_bases
     end
 
-    def display_classes(rels, max_length)
+    def display_classes(prefix, rels, max_length)
       rels.sort.each do |rel|
-        puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel.last}"
+        puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{prefix}#{rel.last}"
       end
       puts "\n"
     end
@@ -556,13 +561,13 @@ In config/initializers/brick.rb appropriate entries would look something like:
 
         # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
         # If auto-controllers and auto-models are both enabled then this makes sense:
+        controller_prefix = (::Brick.config.path_prefix ? "#{::Brick.config.path_prefix}/" : '')
         ::Brick.relations.each do |k, v|
           unless !(controller_name = v.fetch(:resource, nil)&.pluralize) || existing_controllers.key?(controller_name)
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
             # First do the API routes
             full_resource = nil
-            controller_prefix = (::Brick.config.path_prefix ? "#{::Brick.config.path_prefix}/" : '')
             if (schema_name = v.fetch(:schema, nil))
               full_resource = "#{schema_name}/#{v[:resource]}"
               send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
@@ -595,19 +600,19 @@ In config/initializers/brick.rb appropriate entries would look something like:
         if tables.present?
           puts "Classes that can be built from tables:#{' ' * (table_class_length - 38)}  Path:"
           puts "======================================#{' ' * (table_class_length - 38)}  ====="
-          ::Brick.display_classes(tables, table_class_length)
+          ::Brick.display_classes(controller_prefix, tables, table_class_length)
         end
         if views.present?
           puts "Classes that can be built from views:#{' ' * (view_class_length - 37)}  Path:"
           puts "=====================================#{' ' * (view_class_length - 37)}  ====="
-          ::Brick.display_classes(views, view_class_length)
+          ::Brick.display_classes(controller_prefix, views, view_class_length)
         end
 
         if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
-          get('/brick_status', to: 'brick_gem#status', as: 'brick_status')
+          get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: 'brick_status')
         end
         if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
-          get('/brick_orphans', to: 'brick_gem#orphans', as: 'brick_orphans')
+          get("/#{controller_prefix}brick_orphans", to: 'brick_gem#orphans', as: 'brick_orphans')
         end
         if Object.const_defined?('Rswag::Ui') && doc_endpoint = Rswag::Ui.config.config_object[:urls].last
           # Serves JSON swagger info from a path such as  '/api-docs/v1/swagger.json'

metadata

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