brick 1.0.76 → 1.0.78

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 615640b22db113a3959644ee9c2d08ff3a2b37aa10f12dc92d68effef091c228
-  data.tar.gz: b0d3e616b0f44584cf6960f8b8b191fc449b9afc426a6486da11c2deadece7a6
+  metadata.gz: 52f0716e20661f909922bdcddf3401b79b87c33c7b118d1581dfdf9861dd702c
+  data.tar.gz: 45323c512a8c7490b0ac715595ead6e6299d06a442b9c723318b90bcdce6106d
 SHA512:
-  metadata.gz: 02a9f1c74af24e1e23df8b64972d7af8d74bbb870f1510b69d0814f362959e2527f2a7ee9ff7ca65187eb97be4fad1136d64bea7e01a8327a57608924a8f12d8
-  data.tar.gz: '0265977b746d0955c76bef269067d14363cda4373fc5f726f19fb284baf31d0df3bdaae6ffad7301b71cd630a2745db4d30f1da79ec43ef4ae1a92bc986058e9'
+  metadata.gz: 2ef6ac2089e1150bc9c74c6625fc3e7627f5ee06a42d1a2d5fe43790d99156abacc27ba2e042044ee42171f352718d99ae8b468ec9dca4350cd6631bead51ce7
+  data.tar.gz: 8c4da365eb99677930a9f35f0cd5981b91adc790a13ecf55b5369da03fdf1592cccd01f911457cf204aa8769767d5a8537d856ff7080dec75543524b3e680904

data/lib/brick/config.rb

@@ -20,6 +20,15 @@ module Brick
       @serializer = Brick::Serializers::YAML
     end
 
+    # Any path prefixing to apply to all auto-generated Brick routes
+    def path_prefix
+      @mutex.synchronize { @path_prefix }
+    end
+
+    def path_prefix=(path)
+      @mutex.synchronize { @path_prefix = path }
+    end
+
     # Indicates whether Brick models are on or off. Default: true.
     def enable_models
       @mutex.synchronize { !!@enable_models }

data/lib/brick/extensions.rb

@@ -256,12 +256,13 @@ module ActiveRecord
       table_name == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
     end
 
-    def self._brick_index
-      tbl_parts = table_name.split('.')
-      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.first == Apartment.default_schema
-      if (index = tbl_parts.map(&:underscore).join('_')) == index.singularize
-        index << '_index' # Rails applies an _index suffix to that route when the resource name is singular
-      end
+    def self._brick_index(mode = nil)
+      tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
+      tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == Apartment.default_schema
+      tbl_parts.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
+      index << '_index' if mode != :singular && index == index.singularize
       index
     end
 
@@ -554,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)
@@ -605,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
@@ -651,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.
@@ -783,50 +832,76 @@ end
 Module.class_exec do
   alias _brick_const_missing const_missing
   def const_missing(*args)
-    desired_classname = (self == Object) ? args.first.to_s : "#{name}::#{args.first}"
+    requested = args.first.to_s
+    is_controller = requested.end_with?('Controller')
+    # self.name is nil when a model name is requested in an .erb file
+    if self.name && ::Brick.config.path_prefix
+      camelize_prefix = ::Brick.config.path_prefix.camelize
+      # Asking for the prefix module?
+      if self == Object && requested == camelize_prefix
+        Object.const_set(args.first, (built_module = Module.new))
+        puts "module #{camelize_prefix}; end\n"
+        return built_module
+      end
+      split_self_name.shift if (split_self_name = self.name.split('::')).first.blank?
+      if split_self_name.first == camelize_prefix
+        split_self_name.shift # Remove the identified path prefix from the split name
+        if is_controller
+          brick_root = split_self_name.empty? ? self : camelize_prefix.constantize
+        end
+      end
+    end
+    base_module = if self < ActiveRecord::Migration || !self.name
+                    brick_root || Object
+                  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
+    # 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) ||
-                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = args.first.to_s).underscore))
+                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
         ) && (require_dependency(filename) || true) &&
         ((possible = self.const_get(args.first)) && possible.name == desired_classname)
        ) ||
        # If any class has turned up so far (and we're not in the middle of eager loading)
        # then return what we've found.
-       (is_defined && !::Brick.is_eager_loading)
-      return possible
-    end
-    class_name = ::Brick.namify(args.first.to_s)
-    # self.name is nil when a model name is requested in an .erb file
-    base_module = (self < ActiveRecord::Migration || !self.name) ? Object : self
-    # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-    # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-    # that is, checking #qualified_name_for with:  from_mod, const_name
-    # If we want to support namespacing in the future, might have to utilise something like this:
-    # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
-    # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
-    # If the file really exists, go and snag it:
-    if ActiveSupport::Dependencies.search_for_file(class_name.underscore)
-      return base_module._brick_const_missing(*args)
-      # elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-      #   my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
-      #   return my_const
-    else
-      filepath = base_module.name&.split('::')&.[](0..-2) unless base_module == Object
-      filepath = ((filepath || []) + [class_name]).join('/').underscore + '.rb'
-      if ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-        return base_module._brick_const_missing(*args)
+       (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.module_parent == self) ||
+         (possible.instance_of?(Class) && possible == self) # Are we simply searching for ourselves?
+        return possible
       end
     end
-
+    class_name = ::Brick.namify(requested)
     relations = ::Brick.relations
-    # puts "ON OBJECT: #{args.inspect}" if self.module_parent == Object
-    result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
+    result = if ::Brick.enable_controllers? &&
+                is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
+               full_class_name = +''
+               full_class_name << "::#{(split_self_name&.first && split_self_name.join('::')) || self.name}" unless self == Object
                # (Go over to underscores for a moment so that if we have something come in like VABCsController then the model name ends up as
                # Vabc instead of VABC)
-               full_class_name = +''
-               full_class_name << "::#{self.name}" unless self == Object
                singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
                full_class_name << "::#{singular_class_name}"
                if plural_class_name == 'BrickSwagger' ||
@@ -870,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
@@ -929,7 +1016,7 @@ class Object
                                       schema_name
                                     else
                                       matching = "#{schema_name}.#{matching}"
-                                      (Brick.db_schemas[schema_name] ||= 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
@@ -939,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
 
@@ -1197,8 +1284,7 @@ class Object
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
 
-      namespace_name = "#{namespace.name}::" if namespace
-      code = +"class #{namespace_name}#{class_name} < ApplicationController\n"
+      code = +"class #{class_name} < ApplicationController\n"
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
@@ -1341,13 +1427,6 @@ class Object
             code << "  end\n"
             self.define_method :show do
               ::Brick.set_db_schema(params)
-              id = if model.columns_hash[pk.first]&.type == :string
-                     is_pk_string = true
-                     params[:id]
-                   else
-                     params[:id]&.split(/[\/,_]/)
-                   end
-              id = id.first if id.is_a?(Array) && id.length == 1
               instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
             end
           end
@@ -1388,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
 
@@ -1442,7 +1521,14 @@ class Object
     @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
   end\n"
             self.define_method :find_obj do
-              id = is_pk_string ? params[:id] : params[:id]&.split(/[\/,_]/)
+              id = if model.columns_hash[pk.first]&.type == :string
+                     is_pk_string = true
+                     params[:id].gsub('^^sl^^', '/')
+                   else
+                     params[:id]&.split(/[\/,_]/).map do |val_part|
+                       val_part.gsub('^^sl^^', '/')
+                     end
+                   end
               model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
             end
           end
@@ -1465,33 +1551,55 @@ class Object
             # Get column names for params from relations[model.table_name][:cols].keys
           end
         end # unless is_swagger
-        code << "end # #{namespace_name}#{class_name}\n"
+        code << "end # #{class_name}\n"
       end # class definition
       [built_controller, code]
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc, source = nil)
-      if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
-         hm_assoc[:alternate_name] != (source || name.underscore)
-        plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
-        new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
-        # uniq = 1
-        # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
-        #   hm_assoc[:assoc_name] = "#{hm_assoc_name}_#{uniq += 1}"
-        # end
-        # puts new_alt_name
-        # hm_assoc[:assoc_name] = new_alt_name
-        [new_alt_name, true]
-      else
-        assoc_name = ::Brick.namify(hm_assoc[:inverse_table]).pluralize
-        if (needs_class = assoc_name.include?('.')) # If there is a schema name present, use a downcased version for the :has_many
-          assoc_parts = assoc_name.split('.')
-          assoc_parts[0].downcase! if assoc_parts[0] =~ /^[A-Z0-9_]+$/
-          assoc_name = assoc_parts.join('.')
+      assoc_name, needs_class = if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
+                                   hm_assoc[:alternate_name] != (source || name.underscore)
+                                  plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
+                                  new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
+                                  # uniq = 1
+                                  # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
+                                  #   hm_assoc[:assoc_name] = "#{hm_assoc_name}_#{uniq += 1}"
+                                  # end
+                                  # puts new_alt_name
+                                  # hm_assoc[:assoc_name] = new_alt_name
+                                  [new_alt_name, true]
+                                else
+                                  assoc_name = ::Brick.namify(hm_assoc[:inverse_table]).pluralize
+                                  if (needs_class = assoc_name.include?('.')) # If there is a schema name present, use a downcased version for the :has_many
+                                    assoc_parts = assoc_name.split('.')
+                                    assoc_parts[0].downcase! if assoc_parts[0] =~ /^[A-Z0-9_]+$/
+                                    assoc_name = assoc_parts.join('.')
+                                  end
+                                  # hm_assoc[:assoc_name] = assoc_name
+                                  [assoc_name, needs_class]
+                                end
+      # Already have the HM class around?
+      begin
+        if (hm_class = Object._brick_const_missing(hm_class_name = relation[:class_name].to_sym))
+          existing_hm_assocs = hm_class.reflect_on_all_associations.select do |assoc|
+            assoc.macro != :belongs_to && assoc.klass == self && assoc.foreign_key == hm_assoc[:fk]
+          end
+          # Missing a has_many in an existing class?
+          if existing_hm_assocs.empty?
+            options = { inverse_of: hm_assoc[:inverse][:assoc_name].to_sym }
+            # Add class_name and foreign_key where necessary
+            unless hm_assoc[:alternate_name] == (source || name.underscore)
+              options[:class_name] = self.name
+              options[:foreign_key] = hm_assoc[:fk].to_sym
+            end
+            hm_class.send(:has_many, assoc_name.to_sym, options)
+            puts "# ** Adding a missing has_many to #{hm_class.name}:\nclass #{hm_class.name} < #{hm_class.superclass.name}"
+            puts "  has_many :#{assoc_name}, #{options.inspect}\nend\n"
+          end
         end
-        # hm_assoc[:assoc_name] = assoc_name
-        [assoc_name, needs_class]
+      rescue NameError
       end
+      [assoc_name, needs_class]
     end
   end
 end
@@ -1504,6 +1612,7 @@ module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
     conn = _brick_establish_connection(*args)
+    begin
       # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
       # the default DEFERRED mode.
       #   https://discuss.rubyonrails.org/t/failed-write-transaction-upgrades-in-sqlite3/81480/2
@@ -1525,9 +1634,10 @@ module ActiveRecord::ConnectionHandling
           end
         end
       end
-    begin
+      # ::Brick.is_db_present = true
       _brick_reflect_tables
     rescue ActiveRecord::NoDatabaseError
+      # ::Brick.is_db_present = false
     end
     conn
   end
@@ -1535,7 +1645,10 @@ module ActiveRecord::ConnectionHandling
   # This is done separately so that during testing it can be called right after a migration
   # in order to make sure everything is good.
   def _brick_reflect_tables
+    # 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'))
@@ -1543,8 +1656,8 @@ module ActiveRecord::ConnectionHandling
       end
       # Load the initializer for the Apartment gem a little early so that if .excluded_models and
       # .default_schema are specified then we can work with non-tenanted models more appropriately
-      apartment = Object.const_defined?('Apartment')
-      if apartment && File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
+      if (apartment = Object.const_defined?('Apartment')) &&
+         File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
@@ -1556,23 +1669,27 @@ module ActiveRecord::ConnectionHandling
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLServer'
         is_postgres = !is_mssql
-        db_schemas = ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;')
+        db_schemas = if is_postgres
+                       ActiveRecord::Base.execute_sql('SELECT nspname AS table_schema, MAX(oid) AS dt FROM pg_namespace GROUP BY 1 ORDER BY 1;')
+                     else
+                       ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema, NULL AS dt FROM INFORMATION_SCHEMA.tables;')
+                     end
         ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
           row = case row
-                when String
-                  row
                 when Array
-                  row.first
+                  row
                 else
-                  row['table_schema']
+                  [row['table_schema'], row['dt']]
                 end
           # Remove any system schemas
-          s[row] = nil unless ['information_schema', 'pg_catalog',
-                               'INFORMATION_SCHEMA', 'sys'].include?(row)
+          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
@@ -1582,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,
@@ -1601,6 +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[: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. ***"
@@ -1614,7 +1737,7 @@ module ActiveRecord::ConnectionHandling
       measures = []
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       case ActiveRecord::Base.connection.adapter_name
-      when 'PostgreSQL', 'SQLite' # These bring back a hash for each row because the query uses column aliases
+      when 'PostgreSQL', 'SQLite', 'SQLServer' # These bring back a hash for each row because the query uses column aliases
         # schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         ActiveRecord::Base.retrieve_schema_and_tables(sql, is_postgres, is_mssql, schema).each do |r|
           # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
@@ -1804,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)
@@ -1823,7 +1951,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
         AND t.table_name = c.table_name
         LEFT OUTER JOIN
-        (SELECT kcu1.constraint_schema, kcu1.table_name, kcu1.ordinal_position,
+        (SELECT kcu1.constraint_schema, kcu1.table_name, kcu1.column_name, kcu1.ordinal_position,
         tc.constraint_type, kcu1.constraint_name
         FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
         INNER JOIN INFORMATION_SCHEMA.table_constraints AS tc
@@ -1834,9 +1962,9 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         ) AS kcu ON
         -- kcu.CONSTRAINT_CATALOG = t.table_catalog AND
         kcu.CONSTRAINT_SCHEMA = c.table_schema
-        AND kcu.TABLE_NAME = c.table_name#{"
+        AND kcu.TABLE_NAME = c.table_name
+        AND kcu.column_name = c.column_name#{"
     --    AND kcu.position_in_unique_constraint IS NULL" unless is_mssql}
-        AND kcu.ordinal_position = c.ordinal_position
     WHERE t.table_schema #{is_postgres || is_mssql ?
         "NOT IN ('information_schema', 'pg_catalog',
                  'INFORMATION_SCHEMA', 'sys')"
@@ -1845,7 +1973,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if is_postgres && schema }
   --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
       AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
-    ORDER BY 1, t.table_type DESC, 2, c.ordinal_position"
+    ORDER BY 1, t.table_type DESC, 2, kcu.ordinal_position"
     ActiveRecord::Base.execute_sql(sql, *ar_tables)
   end
 
@@ -2090,7 +2218,12 @@ module Brick
                    end
                  end
                end
-      ::Brick.relations.keys.map { |v| [(r = v.pluralize), (model = models[r])&.last&.table_name || v, migrations&.fetch(r, 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

@@ -114,7 +114,7 @@ module Brick
               if @_brick_model
                 pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(@_brick_model&.table_name, nil))
                 obj_name = model_name.split('::').last.underscore
-                path_obj_name = model_name.underscore.tr('/', '_')
+                path_obj_name = @_brick_model._brick_index(:singular)
                 table_name = obj_name.pluralize
                 template_link = nil
                 bts, hms = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
@@ -125,9 +125,11 @@ module Brick
                               "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if (through = hm_assoc.options[:through])
-                                 next unless @_brick_model.instance_methods.include?(through)
+                                 next unless @_brick_model._br_hm_counts.key?(hm_assoc.name) # Skip any weird HMTs that go through a HM with a source_type
+
+                                 next unless @_brick_model.instance_methods.include?(through) &&
+                                             (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 associative = @_brick_model._br_associatives[hm.first]
                                  tbl_nm = if hm_assoc.options[:source]
                                             associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
                                           else
@@ -177,6 +179,7 @@ module Brick
               # %%% 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
               apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
+              prefix = "#{::Brick.config.path_prefix}/" if ::Brick.config.path_prefix
               table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
                                 binding.pry if tbl.is_a?(Symbol)
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
@@ -184,7 +187,7 @@ module Brick
                                 end
                                 s[tbl] = nil
                               end.keys.sort.each_with_object(+'') do |v, s|
-                                s << "<option value=\"#{v.underscore.gsub('.', '/')}\">#{v}</option>"
+                                s << "<option value=\"#{prefix}#{v.underscore.gsub('.', '/')}\">#{v}</option>"
                               end.html_safe
               table_options << '<option value="brick_status">(Status)</option>'.html_safe if ::Brick.config.add_status
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
@@ -350,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
@@ -369,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
@@ -405,6 +405,10 @@ def display_value(col_type, val)
     end
   end
 end
+# Accommodate composite primary keys that include strings with forward-slash characters
+def slashify(*vals)
+  vals.map { |val_part| val_part.is_a?(String) ? val_part.gsub('/', '^^sl^^') : val_part }
+end
 callbacks = {} %>"
 
               if ['index', 'show', 'new', 'update'].include?(args.first)
@@ -461,7 +465,7 @@ window.addEventListener(\"pageshow\", function() {
   });
 
   if (tblSelect) { // Always present
-    var i = schemaSelect ? 1 : 0,
+    var i = #{::Brick.config.path_prefix ? '0' : 'schemaSelect ? 1 : 0'},
         changeoutList = changeout(location.href);
     for (; i < changeoutList.length; ++i) {
       tblSelect.value = changeoutList[i];
@@ -523,15 +527,19 @@ if (grid) {
   function gridMove(evt) {
     var lastHighCell = gridHighCell;
     gridHighCell = document.elementFromPoint(evt.x, evt.y);
-    if (lastHighCell !== gridHighCell) {
-      gridHighCell.classList.add(\"highlight\");
-      if (lastHighCell) lastHighCell.classList.remove(\"highlight\");
-    }
-    var lastHighHeader = gridHighHeader;
-    gridHighHeader = headerCols[gridHighCell.cellIndex];
-    if (lastHighHeader !== gridHighHeader) {
-      if (gridHighHeader) gridHighHeader.classList.add(\"highlight\");
-      if (lastHighHeader) lastHighHeader.classList.remove(\"highlight\");
+    while (gridHighCell && gridHighCell.tagName !== \"TD\" && gridHighCell.tagName !== \"TH\")
+      gridHighCell = gridHighCell.parentElement;
+    if (gridHighCell) {
+      if (lastHighCell !== gridHighCell) {
+        gridHighCell.classList.add(\"highlight\");
+        if (lastHighCell) lastHighCell.classList.remove(\"highlight\");
+      }
+      var lastHighHeader = gridHighHeader;
+      gridHighHeader = headerCols[gridHighCell.cellIndex];
+      if (lastHighHeader !== gridHighHeader) {
+        if (gridHighHeader) gridHighHeader.classList.add(\"highlight\");
+        if (lastHighHeader) lastHighHeader.classList.remove(\"highlight\");
+      }
     }
   }
 }
@@ -661,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
@@ -775,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 %>)
@@ -849,24 +857,25 @@ erDiagram
      @#{table_name}.each do |#{obj_name}|
        hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
-    <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
+    <td><%= link_to '⇛', #{path_obj_name}_path(slashify(#{obj_pk})), { class: 'big-arrow' } %></td>" if obj_pk}
     <% @_brick_sequence.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
       <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name) || (cust_col = cust_cols[col_name])%>><%
          if (bt = bts[col_name])
            if bt[2] # Polymorphic?
-             bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
-             base_class = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class.name.underscore
-             poly_id = #{obj_name}.send(\"#\{bt.first\}_id\")
-             %><%= link_to(\"#\{bt_class\} ##\{poly_id\}\", send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
+             bt_class = #{obj_name}.send(\"#\{bt.first}_type\")
+             base_class_underscored = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class._brick_index(:singular)
+             poly_id = #{obj_name}.send(\"#\{bt.first}_id\")
+             %><%= link_to(\"#\{bt_class} ##\{poly_id}\", send(\"#\{base_class_underscored}_path\".to_sym, poly_id)) if poly_id %><%
            else
+             # binding.pry if @_brick_bt_descrip[bt.first][bt[1].first.first].nil?
              bt_txt = (bt_class = bt[1].first.first).brick_descrip(
                # 0..62 because Postgres column names are limited to 63 characters
                #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (bt_id_col = descrips.last)
              )
              bt_txt ||= \"<span class=\\\"orphan\\\">&lt;&lt; Orphaned ID: #\{val} >></span>\".html_safe if val
              bt_id = bt_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) } %>
-          <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
+          <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class._brick_index(:singular)}_path\".to_sym, bt_id)) : bt_txt %>
         <% end
          elsif (hms_col = hms_cols[col_name])
            if hms_col.length == 1 %>
@@ -877,9 +886,9 @@ erDiagram
                      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.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt
+                     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}\"
+                     \"#\{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? %>
         <% end
@@ -927,7 +936,11 @@ erDiagram
   @resources.each do |r|
   %>
   <tr>
-  <td><%= link_to(r[0], \"/#\{r[0].underscore.tr('.', '/')}\") %></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
@@ -984,12 +997,15 @@ if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(
 end
 %><%= link_to '(See all #{obj_name.pluralize})', #{@_brick_model._brick_index}_path %>
 #{erd_markup}
-<% if obj %>
+<% if obj
+      # path_options = [obj.#{pk}]
+      # path_options << { '_brick_schema':  } if
+      # url = send(:#\{model_name._brick_index(:singular)}_path, obj.#{pk})
+      options = {}
+      options[:url] = send(\"#\{#{model_name}._brick_index(:singular)}_path\".to_sym, obj) if ::Brick.config.path_prefix
+ %>
   <br><br>
-  <%= # path_options = [obj.#{pk}]
-    # path_options << { '_brick_schema':  } if
-    # url = send(:#{model_name.underscore}_path, obj.#{pk})
-    form_for(obj.becomes(#{model_name})) do |f| %>
+  <%= form_for(obj.becomes(#{model_name}), options) do |f| %>
   <table class=\"shadow\">
   <% has_fields = false
     @#{obj_name}.attributes.each do |k, val|
@@ -1008,7 +1024,7 @@ end
           bt_pair = nil
           loop do
             bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
-            # Acxommodate any valid STI by going up the chain of inheritance
+            # Accommodate any valid STI by going up the chain of inheritance
             break unless bt_pair.nil? && poly_class_name = ::Brick.existing_stis[poly_class_name]
           end
           puts \"*** Might be missing an STI class called #\{orig_poly_name\} whose base class should have this:
@@ -1043,7 +1059,7 @@ end
       html_options[:prompt] = \"Select #\{bt_name\}\" %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
       <%= if (bt_obj = bt_class&.find_by(bt_pair[1] => val))
-            link_to('⇛', send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' })
+            link_to('⇛', send(\"#\{bt_class.base_class._brick_index(:singular)\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' })
           elsif val
             \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
           end %>
@@ -1101,9 +1117,10 @@ end
     <tr><td colspan=\"2\">(No displayable fields)</td></tr>
   <% end %>
   </table>
-  <% end %>
+<%   end %>
 
-  #{hms_headers.each_with_object(+'') do |hm, s|
+#{unless args.first == 'new'
+  hms_headers.each_with_object(+'') do |hm, s|
     # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
     next if hm.first.options[:through] && !hm.first.through_reflection
 
@@ -1118,14 +1135,15 @@ end
           <tr><td>(none)</td></tr>
         <% else %>
           <% collection.uniq.each do |#{hm_singular_name}| %>
-            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore.tr('/', '_')}_path([#{obj_pk}])) %></td></tr>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
           <% end %>
         <% end %>
       </table>"
     else
       s
     end
-  end}
+  end
+end}
 <% end %>
 #{script}"
 
@@ -1259,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 = 76
+    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
 
@@ -216,6 +221,12 @@ module Brick
       true
     end
 
+    # Any path prefixing to apply to all auto-generated Brick routes
+    # @api public
+    def path_prefix=(path)
+      Brick.config.path_prefix = path
+    end
+
     # Switches Brick auto-models on or off, for all threads
     # @api public
     def enable_models=(value)
@@ -429,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 = {}
@@ -519,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
@@ -538,23 +549,40 @@ In config/initializers/brick.rb appropriate entries would look something like:
       view_class_length = 37 # Length of "Classes that can be built from views:"
       existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
       ::Rails.application.routes.append do
+        brick_routes_create = lambda do |schema_name, controller_name, v, options|
+          if schema_name # && !Object.const_defined('Apartment')
+            send(:namespace, schema_name) do
+              send(:resources, v[:resource].to_sym, **options)
+            end
+          else
+            send(:resources, v[:resource].to_sym, **options)
+          end
+        end
+
         # %%% 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
-            if (schema_name = v.fetch(:schema, nil)) # && !Object.const_defined('Apartment')
-              send(:namespace, schema_name) do
-                send(:resources, v[:resource].to_sym, **options)
-              end
+            if (schema_name = v.fetch(:schema, nil))
               full_resource = "#{schema_name}/#{v[:resource]}"
-              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              send(:get, "#{::Brick.api_root}#{full_resource}", { to: "#{controller_prefix}#{schema_name}/#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
             else
-              send(:resources, v[:resource].to_sym, **options)
               # Normally goes to something like:  /api/v1/employees
-              send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+              send(:get, "#{::Brick.api_root}#{v[:resource]}", { to: "#{controller_prefix}#{controller_name}#index" }) if Object.const_defined?('Rswag::Ui')
+            end
+            # Now the normal routes
+            if ::Brick.config.path_prefix
+              # Was:  send(:scope, path: ::Brick.config.path_prefix) do
+              send(:namespace, ::Brick.config.path_prefix) do
+                brick_routes_create.call(schema_name, controller_name, v, options)
+              end
+            else
+              brick_routes_create.call(schema_name, controller_name, v, options)
             end
 
             if (class_name = v.fetch(:class_name, nil))
@@ -572,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'

data/lib/generators/brick/install_generator.rb

@@ -139,6 +139,10 @@ module Brick
 # # Settings for the Brick gem
 # # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
 
+# # Custom path prefix to apply to all auto-generated Brick routes.  Also causes auto-generated controllers
+# # to be created inside a module with the same name.
+# ::Brick.path_prefix = 'admin'
+
 # # Normally all are enabled in development mode, and for security reasons only models are enabled in production
 # # and test.  This allows you to either (a) turn off models entirely, or (b) enable controllers, views, and routes
 # # in production.

metadata

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