brick 1.0.77 → 1.0.79

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e113470d473585f716cfa5b835f503448a0d160b60de20f884bf3ce2cc14c08
-  data.tar.gz: 40064f980dd6893cb4e7e47861e00b184983d1a4bbc11b7cbd16fd6caddfab87
+  metadata.gz: eedc546e7e9693459cf228ee376650cdf53c0325e55d50ef24bbf46d421f8738
+  data.tar.gz: c4feda4b5db8334363d05f3418dc172f0dbf408c21192222008a5b9a174ae448
 SHA512:
-  metadata.gz: 4219dfee478a845a949b1ac9b03d0a135504723a892b571ca068af70c2b58ca52025f5e1f2fedb6a97a5b2dcd97280c5f54132b854e285e6daf7bc95d0c2d357
-  data.tar.gz: 67ae65b0de3801bbb2a1817d16b4023116ee7d41491b6d45927bd8197a8f800151f8ce79de34732a55f3dfcabbe301dc69b276899cfd544604d6a64e61220c99
+  metadata.gz: 0c9713099c057b9c9041121576a4f38d5949213926a47d597f88f4a9021ce14cd3df2a30c14b8b929b92ba4549ec4492bdfd8de13cb0a4f710e911c00eab67b6
+  data.tar.gz: 27ca4aa6d40e165aaca5b09cf5b2ce97737b26adc8424b1d25d81b9813100679e9e06a61279c4fd8b96d750a89a4c4cb8eafbfe2d425a4d4c6868644820f297d

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,19 +609,51 @@ 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.)
+                         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
+                         idx = 0
+                         bail_out = nil
+                         x.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
+                                            "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.table_name, a.foreign_key, a.source_reflection.macro]
+                         end
+                         next if bail_out
+                         # 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]}"
+                           nix << k
+                           bail_out = true
+                         elsif src_ref.macro == :belongs_to # Traditional HMT using an associative table
+                           "br_t#{idx}.#{hm.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
-                         poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
+                         fk_col = (inv = hm.inverse_of)&.foreign_key || hm.foreign_key
+                         poly_type = inv.foreign_type if hm.options.key?(:as)
                          pk = hm.klass.primary_key
                          (pk.is_a?(Array) ? pk.first : pk) || '*'
                        end
@@ -652,20 +687,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.table_name}`"
+                          elsif is_postgres || is_mssql
+                            "\"#{(hm.table_name).gsub('.', '"."')}\""
+                          else
+                            hm.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 +858,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 +893,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 +950,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 +1021,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 +1031,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
 
@@ -1309,7 +1388,7 @@ class Object
           ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
           order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
 
-          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), nil,
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by,
                                                                   translations = {},
                                                                   join_array = ::Brick::JoinArray.new)
           # %%% Add custom HM count columns
@@ -1393,7 +1472,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 +1653,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'))
@@ -1583,7 +1663,10 @@ module ActiveRecord::ConnectionHandling
       # .default_schema are specified then we can work with non-tenanted models more appropriately
       if (apartment = Object.const_defined?('Apartment')) &&
          File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
-        load apartment_initializer
+        unless @_apartment_loaded
+          load apartment_initializer
+          @_apartment_loaded = true
+        end
         apartment_excluded = Apartment.excluded_models
       end
       # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
@@ -1607,12 +1690,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 +1707,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 +1726,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 +1935,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 +2226,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 %>)
@@ -817,6 +813,24 @@ erDiagram
                  hms_keys << (assoc_name = (assoc = hm.first).name.to_s)
                  "#{assoc_name.inspect} => [#{(assoc.options[:through] && !assoc.through_reflection).inspect}, #{assoc.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
                end.join(', ')}}
+     # If the resource is missing, has the user simply created an inappropriately pluralised name for a table?
+     @#{table_name} ||= if dym_list = instance_variables.reject do |entry|
+                             entry.to_s.start_with?('@_') ||
+                             ['@cache_hit', '@marked_for_same_origin_verification', '@view_renderer', '@view_flow', '@output_buffer', '@virtual_path'].include?(entry.to_s)
+                           end
+                          msg = \"Can't find resource \\\"#{table_name}\\\".\"
+                           # Can't be sure otherwise of what is up, so check DidYouMean and offer a suggestion.
+                          if (dym = DidYouMean::SpellChecker.new(dictionary: dym_list).correct('@#{table_name}')).present?
+                            msg << \"\nIf you meant \\\"#\{found_dym = dym.first[1..-1]}\\\" then to avoid this message add this entry into inflections.rb:\n\"
+                            msg << \"  inflect.singular('#\{found_dym}', '#{obj_name}')\"
+                            puts
+                            puts \"WARNING:  #\{msg}\"
+                            puts
+                            @#{table_name} = instance_variable_get(dym.first.to_sym)
+                          else
+                            raise ActiveRecord::RecordNotFound.new(msg)
+                          end
+                        end
      col_keys = @#{table_name}.columns.each_with_object([]) do |col, s|
        col_name = col.name
        next if @_brick_incl&.exclude?(col_name) ||
@@ -940,7 +954,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 +1295,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 = 79
 
     # 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
 
@@ -174,13 +179,21 @@ module Brick
 
         case a.macro
         when :belongs_to
-          s.first[a.foreign_key] = if a.polymorphic?
-                                     primary_tables = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }&.last&.fetch(:inverse_table, [])
-                                     models = primary_tables&.map { |table| table.singularize.camelize.constantize }
-                                     [a.name, models, true]
-                                   else
-                                     [a.name, a.klass]
-                                   end
+          if a.polymorphic?
+            rel_poly_bt = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }
+            if (primary_tables = rel_poly_bt&.last&.fetch(:inverse_table, [])).is_a?(Array)
+              models = primary_tables&.map { |table| table.singularize.camelize.constantize }
+              s.first[a.foreign_key] = [a.name, models, true]
+            else
+              # This will come up when using Devise invitable when invited_by_class_name is not
+              # specified because in that circumstance it adds a polymorphic :invited_by association,
+              # along with appropriate invited_by_type and invited_by_id columns.
+              puts "Missing any real indication as to which models \"has_many\" this polymorphic BT in model #{a.active_record.name}:"
+              puts "  belongs_to :#{a.name}, polymorphic: true"
+            end
+          else
+            s.first[a.foreign_key] = [a.name, a.klass]
+          end
         when :has_many, :has_one # This gets has_many as well as has_many :through
           # %%% weed out ones that don't have an available model to reference
           s.last[a.name] = a
@@ -435,7 +448,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 +538,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 +569,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 +608,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.79
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-10 00:00:00.000000000 Z
+date: 2022-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord