brick 1.0.29 → 1.0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a312c2fd5baf0793b4bb4143167b4399c70a514991206a611d525d0784de95b
-  data.tar.gz: bb1af47d2d073dab2c046ff9757fb5db9447f02dd0688330ad7ac8ad678d6751
+  metadata.gz: 8483d9a50013e440cce28f648d09d5322985702f952520cb83c69ad0e5742ce4
+  data.tar.gz: 40072d0504f4d2b1cc9a59e62fef305b939dd977da0e794445adf003dbfb8b7e
 SHA512:
-  metadata.gz: dbfabaf60608b2094e9903cb538bab00706f434f94289b9647320bb128adf0b34317a6404ace34897cf4b2f91700ebd7c028a12b4072ba1ebf9de3380f75add3
-  data.tar.gz: 6e5444ac763c71de71fc1aca64cdb41db6276f1df57f5b556b03bad0b743373f2720865ba7c6ce36f9887d77ffee3b091f32d233121742c4786ca21e8d512705
+  metadata.gz: 9740778159acb464652322ef36eff763a55b38c6579fe0a7550a5797db44928ad6832a8bccc0d924a4d4c5a14dc02658e61bf4220cecff08fc348d540b67e41c
+  data.tar.gz: 1b09db07a284512821b604f1d82f64c4be0c11db7f8a8973f36ab3f78b21804a7fec1eb641bcf1ac5c2ec118cb477c8086c124017c66550753ec4f9beddbd413

data/lib/brick/config.rb

@@ -122,12 +122,32 @@ module Brick
       @mutex.synchronize { @sti_namespace_prefixes = prefixes }
     end
 
-    def schema_to_analyse
-      @mutex.synchronize { @schema_to_analyse }
+    def schema_behavior
+      @mutex.synchronize { @schema_behavior ||= {} }
     end
 
-    def schema_to_analyse=(schema)
-      @mutex.synchronize { @schema_to_analyse = schema }
+    def schema_behavior=(schema)
+      @mutex.synchronize { @schema_behavior = schema }
+    end
+
+    def sti_type_column
+      @mutex.synchronize { @sti_type_column ||= {} }
+    end
+
+    def sti_type_column=(type_col)
+      @mutex.synchronize do
+        (@sti_type_column = type_col).each_with_object({}) do |v, s|
+          if v.last.nil?
+            # Set an STI type column generally
+            ActiveRecord::Base.inheritance_column = v.first
+          else
+            # Custom STI type columns for models built from specific tables
+            (v.last.is_a?(Array) ? v.last : [v.last]).each do |table|
+              ::Brick.relations[table][:sti_col] = v.first
+            end
+          end
+        end
+      end
     end
 
     def default_route_fallback

data/lib/brick/extensions.rb

@@ -104,7 +104,8 @@ module ActiveRecord
             if ch == ']' # Time to process a bracketed thing?
               parts = bracket_name.split('.')
               first_parts = parts[0..-2].map do |part|
-                klass = klass.reflect_on_association(part_sym = part.to_sym).klass
+                klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
+                puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
                 part_sym
               end
               parts = prefix + first_parts + [parts[-1]]
@@ -196,7 +197,7 @@ module ActiveRecord
     def self.bt_link(assoc_name)
       model_underscore = name.underscore
       assoc_name = CGI.escapeHTML(assoc_name.to_s)
-      model_path = Rails.application.routes.url_helpers.send("#{model_underscore.pluralize}_path".to_sym)
+      model_path = Rails.application.routes.url_helpers.send("#{model_underscore.tr('/', '_').pluralize}_path".to_sym)
       link = Class.new.extend(ActionView::Helpers::UrlHelper).link_to(name, model_path)
       model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
     end
@@ -306,8 +307,12 @@ module ActiveRecord
 
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
+        tbl_no_schema = table.name.split('.').last
         columns.each do |col|
-          selects << "\"#{table.name}\".\"#{col.name}\""
+          if (col_name = col.name) == 'class'
+            col_alias = ' AS _class'
+          end
+          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{col_alias}"
         end
       end
 
@@ -344,12 +349,13 @@ module ActiveRecord
           next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(ks.last)
 
           join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
+          distinct!
         end
         wheres[k] = v.split(',')
       end
 
       if join_array.present?
-        left_outer_joins!(join_array) # joins!(join_array)
+        left_outer_joins!(join_array)
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
         (rel_dupe = dup)._arel_alias_names
         core_selects = selects.dup
@@ -360,10 +366,10 @@ module ActiveRecord
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
 
-            tbl_name = field_tbl_names[v.first][k1] ||= shift_or_first(chains[k1])
+            tbl_name = (field_tbl_names[v.first][k1] ||= shift_or_first(chains[k1])).split('.').last
             field_tbl_name = nil
             v1.map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
-              field_tbl_name = field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])
+              field_tbl_name = (field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])).split('.').last
 
               selects << "#{"\"#{field_tbl_name}\".\"#{sel_col.last}\""} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
               v1[idx] << col_alias
@@ -416,10 +422,13 @@ module ActiveRecord
           on_clause << "#{tbl_alias}.#{poly_type} = '#{name}'"
         end
         join_clause = "LEFT OUTER
-JOIN (SELECT #{selects.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name} GROUP BY #{(1..selects.length).to_a.join(', ')}) AS #{tbl_alias}"
+JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
+          }) AS _ct_ FROM #{associative&.table_name || hm.klass.table_name
+          } GROUP BY #{(1..selects.length).to_a.join(', ')}) AS #{tbl_alias}"
         joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
       end
       where!(wheres) unless wheres.empty?
+      limit!(1000) # Don't want to get too carried away just yet
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
@@ -480,11 +489,13 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
       alias _brick_autoload_module! autoload_module!
       def autoload_module!(*args)
         into, const_name, qualified_name, path_suffix = args
-        if (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)&.constantize)
+        base_class_name = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)
+        base_class_name = "::#{base_class_name}" unless base_class_name.start_with?('::')
+        if (base_class = base_class_name&.constantize)
           ::Brick.sti_models[qualified_name] = { base: base_class }
           # Build subclass and place it into the specially STI-namespaced module
           into.const_set(const_name.to_sym, klass = Class.new(base_class))
-          # %%% used to also have:  autoload_once_paths.include?(base_path) || 
+          # %%% used to also have:  autoload_once_paths.include?(base_path) ||
           autoloaded_constants << qualified_name unless autoloaded_constants.include?(qualified_name)
           klass
         elsif (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{const_name}", nil)&.constantize)
@@ -498,94 +509,153 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
   end
 end
 
-class Object
-  class << self
-    alias _brick_const_missing const_missing
-    def const_missing(*args)
-      return self.const_get(args.first) if self.const_defined?(args.first)
-      return Object.const_get(args.first) if Object.const_defined?(args.first) unless self == Object
-
-      class_name = args.first.to_s
-      # 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 !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = (self.name || class_name)&.split('::'))
-        filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
-      end
-      if is_found
-        return self._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
-      end
+Module.class_exec do
+  alias _brick_const_missing const_missing
+  def const_missing(*args)
+    if (self.const_defined?(args.first) && (possible = self.const_get(args.first)) && possible != self) ||
+       (self != Object && Object.const_defined?(args.first) &&
+         (
+           (possible = Object.const_get(args.first)) &&
+           (possible != self || (possible == self && possible.is_a?(Class)))
+         )
+       )
+      return possible
+    end
+    class_name = args.first.to_s
+    # 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 !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = (self.name || class_name)&.split('::'))
+      filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
+    end
+    if is_found
+      return self._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
+    end
 
-      relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-      result = if ::Brick.enable_controllers? && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
-                 # Otherwise now it's up to us to fill in the gaps
-                 if (model = plural_class_name.singularize.constantize)
-                   # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
-                   build_controller(class_name, plural_class_name, model, relations)
-                 end
-               elsif ::Brick.enable_models?
-                 # 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
-                 plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
-                 singular_table_name = ActiveSupport::Inflector.underscore(model_name)
- 
+    relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
+    # 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?
+               # Otherwise now it's up to us to fill in the gaps
+               # (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
+               full_class_name << "::#{plural_class_name.underscore.singularize.camelize}"
+               if (model = self.const_get(full_class_name))
+                 # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
+                 Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
+               end
+             elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
+                   self == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
+                   (schema_name = [(singular_table_name = class_name.underscore),
+                                   (table_name = singular_table_name.pluralize),
+                                   class_name,
+                                   (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }&.camelize ||
+                                  (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
+               # Build out a module for the schema if it's namespaced
+               # schema_name = schema_name.camelize
+               self.const_set(schema_name.to_sym, (built_module = Module.new))
+
+               [built_module, "module #{schema_name}; end\n"]
+               #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
+             elsif ::Brick.enable_models?
+               # 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
+
+               if self != Object || # Are we in some namespace? ...
+                  (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil)&.constantize) # ... or part of an auto-STI namespace?
+                 schema_name = [(singular_schema_name = name.underscore),
+                                (schema_name = singular_schema_name.pluralize),
+                                name,
+                                name.pluralize].find { |s| Brick.db_schemas.include?(s) }
+               end
+               plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
+               # If it's namespaced then we turn the first part into what would be a schema name
+               singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
+
+               if base_model
+                 schema_name = name.underscore # For the auto-STI namespace models
+                 table_name = base_model.table_name
+                 Object.send(:build_model, self, model_name, singular_table_name, table_name, relations, table_name)
+               else
                  # Adjust for STI if we know of a base model for the requested model name
+                 # %%% Does not yet work with namespaced model names.  Perhaps prefix with plural_class_name when doing the lookups here.
                  table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
                                 base_model.table_name
                               else
                                 ActiveSupport::Inflector.pluralize(singular_table_name)
                               end
- 
+
                  # Maybe, just maybe there's a database table that will satisfy this need
-                 if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
-                   build_model(model_name, singular_table_name, table_name, relations, matching)
+                 if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
+                   Object.send(:build_model, schema_name, model_name, singular_table_name, table_name, relations, matching)
                  end
                end
-      if result
-        built_class, code = result
-        puts "\n#{code}"
-        built_class
-      elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}")
+             end
+    if result
+      built_class, code = result
+      puts "\n#{code}"
+      built_class
+    elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}") && !schema_name
 #         module_prefixes = type_name.split('::')
 #         path = self.name.split('::')[0..-2] + []
 #         module_prefixes.unshift('') unless module_prefixes.first.blank?
 #         candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
-        self._brick_const_missing(*args)
-      else
-        puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
-        self._brick_const_missing(*args)
-      end
+      self._brick_const_missing(*args)
+    elsif self != Object
+      module_parent.const_missing(*args)
+    else
+      puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
+      self._brick_const_missing(*args)
     end
+  end
+end
+
+class Object
+  class << self
 
   private
 
-    def build_model(model_name, singular_table_name, table_name, relations, matching)
+    def build_model(schema_name, model_name, singular_table_name, table_name, relations, matching)
+      full_name = if schema_name.blank?
+                    model_name
+                  else # Prefix the schema to the table name + prefix the schema namespace to the class name
+                    schema_module = if schema_name.instance_of?(Module) # from an auto-STI namespace?
+                                      schema_name
+                                    else
+                                      matching = "#{schema_name}.#{matching}"
+                                      (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.singularize.camelize))
+                                    end
+                    "#{schema_module&.name}::#{model_name}"
+                  end
+
       return if ((is_view = (relation = relations[matching]).key?(:isView)) && ::Brick.config.skip_database_views) ||
                 ::Brick.config.exclude_tables.include?(matching)
 
       # 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.titleize}::")
+        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(model_name)}\"."
         end
         return
       end
 
-      if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil) || ::Brick.existing_stis[model_name]&.constantize)
+      if (base_model = ::Brick.sti_models[full_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_name]&.constantize)
         is_sti = true
       else
         base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
       end
-      code = +"class #{model_name} < #{base_model.name}\n"
+      hmts = nil
+      code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
-        Object.const_set(model_name.to_sym, new_model_class)
+        (schema_module || Object).const_set(model_name.to_sym, new_model_class)
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" unless table_name == matching
 
@@ -618,6 +688,10 @@ class Object
         else
           code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
         end
+        if (sti_col = relation.fetch(:sti_col, nil))
+          new_model_class.send(:'inheritance_column=', sti_col)
+          code << "  self.inheritance_column = #{sti_col.inspect}\n"
+        end
 
         unless is_sti
           fks = relation[:fks] || {}
@@ -635,7 +709,21 @@ class Object
             build_bt_or_hm(relations, model_name, relation, hmts, assoc, inverse_assoc_name, invs, code) unless invs.is_a?(Array)
             hmts
           end
-          hmts.each do |hmt_fk, fks|
+          # # Not NULLables
+          # # %%% For the minute we've had to pull this out because it's been troublesome implementing the NotNull validator
+          # relation[:cols].each do |col, datatype|
+          #   if (datatype[3] && _brick_primary_key.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
+          #      ::Brick.config.not_nullables.include?("#{matching}.#{col}")
+          #     code << "  validates :#{col}, not_null: true\n"
+          #     self.send(:validates, col.to_sym, { not_null: true })
+          #   end
+          # end
+        end
+      end # class definition
+      # Having this separate -- will this now work out better?
+        built_model.class_exec do
+          hmts&.each do |hmt_fk, fks|
+            hmt_fk = hmt_fk.tr('.', '_')
             fks.each do |fk|
               through = fk.first[:assoc_name]
               hmt_name = if fks.length > 1
@@ -649,25 +737,19 @@ class Object
                          else
                            hmt_fk
                          end
-              source = fk.last unless hmt_name.singularize == fk.last
-              code << "  has_many :#{hmt_name}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
-              options = { through: assoc_name }
-              options[:source] = source.to_sym if source
+              options = { through: through.to_sym }
+              if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
+                hmt_name = "#{hmt_name.singularize}_#{fk.first[:assoc_name]}"
+                options[:class_name] = fk.first[:inverse_table].singularize.camelize
+                options[:foreign_key] = fk.first[:fk].to_sym
+              end
+              options[:source] = fk.last.to_sym unless hmt_name.singularize == fk.last
+              code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
               self.send(:has_many, hmt_name.to_sym, **options)
             end
           end
-          # # Not NULLables
-          # # %%% For the minute we've had to pull this out because it's been troublesome implementing the NotNull validator
-          # relation[:cols].each do |col, datatype|
-          #   if (datatype[3] && _brick_primary_key.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
-          #      ::Brick.config.not_nullables.include?("#{matching}.#{col}")
-          #     code << "  validates :#{col}, not_null: true\n"
-          #     self.send(:validates, col.to_sym, { not_null: true })
-          #   end
-          # end
         end
-        code << "end # model #{model_name}\n\n"
-      end # class definition
+        code << "end # model #{full_name}\n\n"
       [built_model, code]
     end
 
@@ -678,12 +760,13 @@ class Object
                 # Try to take care of screwy names if this is a belongs_to going to an STI subclass
                 assoc_name = if (primary_class = assoc.fetch(:primary_class, nil)) &&
                                sti_inverse_assoc = primary_class.reflect_on_all_associations.find do |a|
-                                 a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key
+                                 a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] == a.foreign_key
                                end
                                sti_inverse_assoc.options[:inverse_of]&.to_s || assoc_name
                              else
                                assoc[:assoc_name]
                              end
+                options[:optional] = true if assoc.key?(:optional)
                 if assoc.key?(:polymorphic)
                   options[:polymorphic] = true
                 else
@@ -710,7 +793,7 @@ class Object
                 if assoc.key?(:polymorphic)
                   options[:as] = assoc[:fk].to_sym
                 else
-                  need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
+                  need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table].split('.').last)}_id" != assoc[:fk]
                 end
                 # fks[table_name].find { |other_assoc| other_assoc.object_id != assoc.object_id && other_assoc[:assoc_name] == assoc[assoc_name] }
                 if (has_ones = ::Brick.config.has_ones&.fetch(model_name, nil))&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name))
@@ -727,7 +810,11 @@ class Object
               end
       # Figure out if we need to specially call out the class_name and/or foreign key
       # (and if either of those then definitely also a specific inverse_of)
-      options[:class_name] = assoc[:primary_class]&.name || singular_table_name.camelize if need_class_name
+      if (singular_table_parts = singular_table_name.split('.')).length > 1 &&
+         ::Brick.config.schema_behavior[:multitenant] && singular_table_parts.first == 'public'
+        singular_table_parts.shift
+      end
+      options[:class_name] = "::#{assoc[:primary_class]&.name || singular_table_parts.map(&:camelize).join('::')}" if need_class_name
       # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
       if need_fk # Funky foreign key?
         options[:foreign_key] = if assoc[:fk].is_a?(Array)
@@ -737,7 +824,7 @@ class Object
                                   assoc[:fk].to_sym
                                 end
       end
-      options[:inverse_of] = inverse_assoc_name.to_sym if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of)
+      options[:inverse_of] = inverse_assoc_name.tr('.', '_').to_sym if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of)
 
       # Prepare a list of entries for "has_many :through"
       if macro == :has_many
@@ -748,19 +835,20 @@ class Object
         end
       end
       # And finally create a has_one, has_many, or belongs_to for this association
-      assoc_name = assoc_name.to_sym
+      assoc_name = assoc_name.tr('.', '_').to_sym
       code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
       self.send(macro, assoc_name, **options)
     end
 
-    def build_controller(class_name, plural_class_name, model, relations)
+    def build_controller(namespace, class_name, plural_class_name, model, relations)
       table_name = ActiveSupport::Inflector.underscore(plural_class_name)
       singular_table_name = ActiveSupport::Inflector.singularize(table_name)
       pk = model._brick_primary_key(relations.fetch(table_name, nil))
 
-      code = +"class #{class_name} < ApplicationController\n"
+      namespace_name = "#{namespace.name}::" if namespace
+      code = +"class #{namespace_name}#{class_name} < ApplicationController\n"
       built_controller = Class.new(ActionController::Base) do |new_controller_class|
-        Object.const_set(class_name.to_sym, new_controller_class)
+        (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
         code << "  def index\n"
         code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
@@ -787,9 +875,10 @@ class Object
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
           counts = hm_counts.each_with_object([]) { |v, s| s << "_br_#{v.first}._ct_ AS _br_#{v.first}_ct" }
-          # *selects, 
           instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
-          # binding.pry
+          if namespace && (idx = lookup_context.prefixes.index(table_name))
+            lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
+          end
           @_brick_bt_descrip = bt_descrip
           @_brick_hm_counts = hm_counts
           @_brick_join_array = join_array
@@ -814,9 +903,9 @@ class Object
           code << "  # (Define :new, :create)\n"
 
           if model.primary_key
-            if (schema = ::Brick.config.schema_to_analyse) && ::Brick.db_schemas&.include?(schema)
-              ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
-            end
+            # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
+            #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
+            # end
 
             is_need_params = true
             # code << "  # (Define :edit, and :destroy)\n"
@@ -827,7 +916,6 @@ class Object
             code << "  end\n"
             self.define_method :update do
               ::Brick.set_db_schema(params)
-
               if request.format == :csv # Importing CSV?
                 require 'csv'
                 # See if internally it's likely a TSV file (tab-separated)
@@ -843,7 +931,9 @@ class Object
               #   return
               end
 
-              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(params[:id].split(','))))
+              id = params[:id]&.split(/[\/,_]/)
+              id = id.first if id.is_a?(Array) && id.length == 1
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(id)))
               obj = obj.first if obj.is_a?(Array)
               obj.send(:update, send(params_name = params_name.to_sym))
             end
@@ -851,7 +941,7 @@ class Object
 
           if is_need_params
             code << "private\n"
-            code << "  def params\n"
+            code << "  def #{params_name}\n"
             code << "    params.require(:#{singular_table_name}).permit(#{model.columns_hash.keys.map { |c| c.to_sym.inspect }.join(', ')})\n"
             code << "  end\n"
             self.define_method(params_name) do
@@ -861,7 +951,7 @@ class Object
             # Get column names for params from relations[model.table_name][:cols].keys
           end
         end
-        code << "end # #{class_name}\n\n"
+        code << "end # #{namespace_name}#{class_name}\n\n"
       end # class definition
       [built_controller, code]
     end
@@ -871,7 +961,8 @@ class Object
         plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
         [hm_assoc[:alternate_name] == name.underscore ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural, true]
       else
-        [ActiveSupport::Inflector.pluralize(hm_assoc[:inverse_table]), nil]
+        assoc_name = hm_assoc[:inverse_table].pluralize
+        [assoc_name, assoc_name.include?('.')]
       end
     end
   end
@@ -889,18 +980,29 @@ module ActiveRecord::ConnectionHandling
     conn
   end
 
+  # 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
+    initializer_loaded = false
     if (relations = ::Brick.relations).empty?
-    # Only for Postgres?  (Doesn't work in sqlite3)
-    # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
+      # 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'))
+        initializer_loaded = load brick_initializer
+      end
+      # Only for Postgres?  (Doesn't work in sqlite3)
+      # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
-    schema_sql = 'SELECT NULL AS table_schema;'
-    case ActiveRecord::Base.connection.adapter_name
+      schema_sql = 'SELECT NULL AS table_schema;'
+      case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
-        schema = 'public' # Too early at this point to be able to pick up:  Brick.config.schema_to_analyse
+        if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
+           (sta = multitenancy[:schema_to_analyse]) != 'public')
+          ::Brick.default_schema = schema = sta
+          ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
+        end
         schema_sql = 'SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;'
       when 'Mysql2'
-        schema = ActiveRecord::Base.connection.current_database
+        ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
       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,
@@ -913,8 +1015,29 @@ module ActiveRecord::ConnectionHandling
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
       end
 
-      sql ||= ActiveRecord::Base.send(:sanitize_sql_array, [
-        "SELECT t.table_name AS relation_name, t.table_type,
+      unless (db_schemas = ActiveRecord::Base.execute_sql(schema_sql)).is_a?(Array)
+        db_schemas = db_schemas.to_a
+      end
+      unless db_schemas.empty?
+        ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
+          row = row.is_a?(String) ? row : row['table_schema']
+          # Remove any system schemas
+          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
+        end
+      end
+
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+        if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
+          if ::Brick.db_schemas.key?(possible_schema)
+            ::Brick.default_schema = schema = possible_schema
+            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. ***"
+          end
+        end
+      end
+
+      sql ||= "SELECT t.table_schema AS schema, t.table_name AS relation_name, t.table_type,
           c.column_name, c.data_type,
           COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
           tc.constraint_type AS const, kcu.constraint_name AS \"key\",
@@ -932,18 +1055,22 @@ module ActiveRecord::ConnectionHandling
             ON kcu.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
             AND kcu.TABLE_NAME = tc.TABLE_NAME
             AND kcu.CONSTRAINT_NAME = tc.constraint_name
-        WHERE t.table_schema = ? -- COALESCE(current_setting('SEARCH_PATH'), 'public')
+        WHERE t.table_schema NOT IN ('information_schema', 'pg_catalog')#{"
+          AND t.table_schema = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }
   --          AND t.table_type IN ('VIEW') -- 'BASE TABLE', 'FOREIGN TABLE'
           AND t.table_name NOT IN ('pg_stat_statements', 'ar_internal_metadata', 'schema_migrations')
-        ORDER BY 1, t.table_type DESC, c.ordinal_position", schema
-      ])
-
+        ORDER BY 1, t.table_type DESC, c.ordinal_position"
       measures = []
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'SQLite' # 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.execute_sql(sql).each do |r|
-          # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
-          relation = relations[(relation_name = r['relation_name'])]
+          relation_name = if ![schema, 'public'].include?(r['schema']) && !::Brick.config.schema_behavior[:multitenant]
+                            "#{schema_name = r['schema']}.#{r['relation_name']}"
+                          else
+                            r['relation_name']
+                          end
+          relation = relations[relation_name]
           relation[:isView] = true if r['table_type'] == 'VIEW'
           col_name = r['column_name']
           key = case r['const']
@@ -961,7 +1088,6 @@ module ActiveRecord::ConnectionHandling
         end
       else # MySQL2 acts a little differently, bringing back an array for each row
         ActiveRecord::Base.execute_sql(sql).each do |r|
-          # next if internal_views.include?(r['relation_name']) # Skip internal views such as v_all_assessments
           relation = relations[(relation_name = r[0])] # here relation represents a table or view from the database
           relation[:isView] = true if r[1] == 'VIEW' # table_type
           col_name = r[2]
@@ -1000,11 +1126,11 @@ module ActiveRecord::ConnectionHandling
       #     end
       #   end
       # end
-
+      # schema = ::Brick.default_schema # Reset back for this next round of fun
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2'
-        sql = ActiveRecord::Base.send(:sanitize_sql_array, [
-          "SELECT kcu1.TABLE_NAME, kcu1.COLUMN_NAME, kcu2.TABLE_NAME AS primary_table, kcu1.CONSTRAINT_NAME
+        sql = "SELECT kcu1.CONSTRAINT_SCHEMA, kcu1.TABLE_NAME, kcu1.COLUMN_NAME,
+                  kcu2.CONSTRAINT_SCHEMA AS primary_schema, kcu2.TABLE_NAME AS primary_table, kcu1.CONSTRAINT_NAME AS CONSTRAINT_SCHEMA_FK
           FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
             INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu1
               ON kcu1.CONSTRAINT_CATALOG = rc.CONSTRAINT_CATALOG
@@ -1014,10 +1140,9 @@ module ActiveRecord::ConnectionHandling
               ON kcu2.CONSTRAINT_CATALOG = rc.UNIQUE_CONSTRAINT_CATALOG
               AND kcu2.CONSTRAINT_SCHEMA = rc.UNIQUE_CONSTRAINT_SCHEMA
               AND kcu2.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
-              AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION
-          WHERE kcu1.CONSTRAINT_SCHEMA = ? -- COALESCE(current_setting('SEARCH_PATH'), 'public')", schema
+              AND kcu2.ORDINAL_POSITION = kcu1.ORDINAL_POSITION#{"
+          WHERE kcu1.CONSTRAINT_SCHEMA = COALESCE(current_setting('SEARCH_PATH'), 'public')" if schema }"
           # AND kcu2.TABLE_NAME = ?;", Apartment::Tenant.current, table_name
-        ])
       when 'SQLite'
         sql = "SELECT m.name, fkl.\"from\", fkl.\"table\", m.name || '_' || fkl.\"from\" AS constraint_name
         FROM sqlite_master m
@@ -1026,12 +1151,12 @@ module ActiveRecord::ConnectionHandling
       else
       end
       if sql
-        ::Brick.db_schemas = ActiveRecord::Base.execute_sql(schema_sql)
-        ::Brick.db_schemas = ::Brick.db_schemas.to_a unless ::Brick.db_schemas.is_a?(Array)
-        ::Brick.db_schemas.map! { |row| row['table_schema'] } unless ::Brick.db_schemas.empty? || ::Brick.db_schemas.first.is_a?(String)
-        ::Brick.db_schemas -= ['information_schema', 'pg_catalog']
+        # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         ActiveRecord::Base.execute_sql(sql).each do |fk|
           fk = fk.values unless fk.is_a?(Array)
+          # Multitenancy makes things a little more general overall
+          fk[0] = nil if fk[0] == 'public' || (is_multitenant && fk[0] == schema)
+          fk[3] = nil if fk[3] == 'public' || (is_multitenant && fk[3] == schema)
           ::Brick._add_bt_and_hm(fk, relations)
         end
       end
@@ -1044,11 +1169,7 @@ module ActiveRecord::ConnectionHandling
       views.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
     end
 
-    # Try to load the initializer pretty danged early
-    if File.exist?(brick_initialiser = Rails.root.join('config/initializers/brick.rb'))
-      load brick_initialiser
-      ::Brick.load_additional_references
-    end
+    ::Brick.load_additional_references if initializer_loaded
   end
 end
 
@@ -1075,35 +1196,53 @@ module Brick
   # rubocop:enable Style/CommentedKeyword
 
   class << self
-    def _add_bt_and_hm(fk, relations, is_polymorphic = false)
-      bt_assoc_name = fk[1].underscore
-      bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
-
-      bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
+    def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
+      bt_assoc_name = fk[2]
+      unless is_polymorphic
+        bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
+                          bt_assoc_name[0..-4]
+                        elsif bt_assoc_name.downcase.end_with?('id') && bt_assoc_name.exclude?('_')
+                          bt_assoc_name[0..-3] # Make the bold assumption that we can just peel off any final ID part
+                        else
+                          "#{bt_assoc_name}_bt"
+                        end
+      end
+      # %%% Temporary schema patch
+      for_tbl = fk[1]
+      fk[1] = "#{fk[0]}.#{fk[1]}" if fk[0] # && fk[0] != ::Brick.default_schema
+      bts = (relation = relations.fetch(fk[1], nil))&.fetch(:fks) { relation[:fks] = {} }
       # %%% Do we miss out on has_many :through or even HM based on constantizing this model early?
       # Maybe it's already gotten this info because we got as far as to say there was a unique class
-      primary_table = (is_class = fk[2].is_a?(Hash) && fk[2].key?(:class)) ? (primary_class = fk[2][:class].constantize).table_name : fk[2]
+      primary_table = if (is_class = fk[4].is_a?(Hash) && fk[4].key?(:class))
+                        pri_tbl = (primary_class = fk[4][:class].constantize).table_name
+                      else
+                        is_schema = fk[3] != ::Brick.default_schema && (::Brick.config.schema_behavior[:multitenant] || fk[3] != 'public')
+                        pri_tbl = fk[4]
+                        fk[3] && is_schema ? "#{fk[3]}.#{pri_tbl}" : pri_tbl
+                      end
       hms = (relation = relations.fetch(primary_table, nil))&.fetch(:fks) { relation[:fks] = {} } unless is_class
 
-      unless (cnstr_name = fk[3])
+      unless (cnstr_name = fk[5])
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
-        cnstr_base = cnstr_name = "(brick) #{fk[0]}_#{is_class ? fk[2][:class].underscore : fk[2]}"
+        pri_tbl = is_class ? fk[4][:class].underscore : pri_tbl
+        pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl.singularize != bt_assoc_name
+        cnstr_base = cnstr_name = "(brick) #{for_tbl}_#{pri_tbl}"
         cnstr_added_num = 1
         cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
         missing = []
-        missing << fk[0] unless relations.key?(fk[0])
+        missing << fk[1] unless relations.key?(fk[1])
         missing << primary_table unless is_class || relations.key?(primary_table)
         unless missing.empty?
           tables = relations.reject { |_k, v| v.fetch(:isView, nil) }.keys.sort
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
           return
         end
-        unless (cols = relations[fk[0]][:cols]).key?(fk[1]) || (is_polymorphic && cols.key?("#{fk[1]}_id") && cols.key?("#{fk[1]}_type"))
+        unless (cols = relations[fk[1]][:cols]).key?(fk[2]) || (is_polymorphic && cols.key?("#{fk[2]}_id") && cols.key?("#{fk[2]}_type"))
           columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
-          puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
+          puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[2]}. (Columns present in #{fk[1]} are #{columns.join(', ')}.)"
           return
         end
-        if (redundant = bts.find { |_k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == primary_table })
+        if (redundant = bts.find { |_k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[1] && v[:fk] == fk[2] && v[:inverse_table] == primary_table })
           if is_class && !redundant.last.key?(:class)
             redundant.last[:primary_class] = primary_class # Round out this BT so it can find the proper :source for a HMT association that references an STI subclass
           else
@@ -1115,18 +1254,19 @@ module Brick
       if (assoc_bt = bts[cnstr_name])
         if is_polymorphic
           # Assuming same fk (don't yet support composite keys for polymorphics)
-          assoc_bt[:inverse_table] << fk[2]
+          assoc_bt[:inverse_table] << fk[4]
         else # Expect we could have a composite key going
           if assoc_bt[:fk].is_a?(String)
-            assoc_bt[:fk] = [assoc_bt[:fk], fk[1]] unless fk[1] == assoc_bt[:fk]
-          elsif assoc_bt[:fk].exclude?(fk[1])
-            assoc_bt[:fk] << fk[1]
+            assoc_bt[:fk] = [assoc_bt[:fk], fk[2]] unless fk[2] == assoc_bt[:fk]
+          elsif assoc_bt[:fk].exclude?(fk[2])
+            assoc_bt[:fk] << fk[2]
           end
-          assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
+          assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[2]}"
         end
       else
         inverse_table = [primary_table] if is_polymorphic
-        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: inverse_table || primary_table }
+        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[2], assoc_name: bt_assoc_name, inverse_table: inverse_table || primary_table }
+        assoc_bt[:optional] = true if is_optional
         assoc_bt[:polymorphic] = true if is_polymorphic
       end
       if is_class
@@ -1136,21 +1276,21 @@ module Brick
         # assoc_bt[:inverse_of] = primary_class.reflect_on_all_associations.find { |a| a.foreign_key == bt[1] }
       end
 
-      return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
+      return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[1] == exclusion[0] && fk[2] == exclusion[1] && primary_table == exclusion[2] } || hms.nil?
 
       if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{cnstr_name}"), nil))
         if assoc_hm[:fk].is_a?(String)
-          assoc_hm[:fk] = [assoc_hm[:fk], fk[1]] unless fk[1] == assoc_hm[:fk]
-        elsif assoc_hm[:fk].exclude?(fk[1])
-          assoc_hm[:fk] << fk[1]
+          assoc_hm[:fk] = [assoc_hm[:fk], fk[2]] unless fk[2] == assoc_hm[:fk]
+        elsif assoc_hm[:fk].exclude?(fk[2])
+          assoc_hm[:fk] << fk[2]
         end
         assoc_hm[:alternate_name] = "#{assoc_hm[:alternate_name]}_#{bt_assoc_name}" unless assoc_hm[:alternate_name] == bt_assoc_name
         assoc_hm[:inverse] = assoc_bt
       else
-        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: for_tbl.pluralize, alternate_name: bt_assoc_name, inverse_table: fk[1], inverse: assoc_bt }
         assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-        hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
+        hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
       end
       assoc_bt[:inverse] = assoc_hm
     end

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

@@ -55,7 +55,9 @@ module Brick
               unless (is_template_exists = _brick_template_exists?(*args, **options))
                 # Need to return true if we can fill in the blanks for a missing one
                 # args will be something like:  ["index", ["categories"]]
-                model = args[1].map(&:camelize).join('::').singularize.constantize
+                args[1] = args[1].each_with_object([]) { |a, s| s.concat(a.split('/')) }
+                args[1][args[1].length - 1] = args[1].last.singularize # Make sure the last item, defining the class name, is singular
+                model = args[1].map(&:camelize).join('::').constantize
                 if is_template_exists = model && (
                      ['index', 'show'].include?(args.first) || # Everything has index and show
                      # Only CUD stuff has create / update / destroy
@@ -72,9 +74,9 @@ module Brick
                        fk_name.zip(pk.map { |pk_part| "#{obj_name}.#{pk_part}" })
                      else
                        pk = pk.each_with_object([]) { |pk_part, s| s << "#{obj_name}.#{pk_part}" }
-                       [[fk_name, "#{pk.length == 1 ? pk.first : pk.inspect}"]]
+                       [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
                      end
-              keys << [hm_assoc.inverse_of.foreign_type, "#{hm_assoc.active_record.name}"] if hm_assoc.options.key?(:as)
+              keys << [hm_assoc.inverse_of.foreign_type, hm_assoc.active_record.name] if hm_assoc.options.key?(:as)
               keys.map { |x| "#{x.first}: #{x.last}"}.join(', ')
             end
 
@@ -84,8 +86,9 @@ module Brick
 
               model_name = @_brick_model.name
               pk = @_brick_model._brick_primary_key(::Brick.relations.fetch(model_name, nil))
-              obj_name = model_name.underscore
-              table_name = model_name.pluralize.underscore
+              obj_name = model_name.split('::').last.underscore
+              path_obj_name = model_name.underscore.tr('/', '_')
+              table_name = obj_name.pluralize
               template_link = nil
               bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
               hms_columns = [] # Used for 'index'
@@ -108,21 +111,21 @@ module Brick
                                               "#{obj_name}.#{attrib_name} || 0"
                                             end
 "<%= ct = #{set_ct}
-     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
+     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
                                  else # has_one
 "<%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>\n"
                                  end
                 elsif args.first == 'show'
-                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
+                  hm_stuff << "<%= link_to '#{assoc_name}', #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, "@#{obj_name}", pk)} }) %>\n"
                 end
                 s << hm_stuff
               end
 
-              schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
+              schema_options = ::Brick.db_schemas.keys.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
               # %%% 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
-              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
-                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).sort
+                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>" }.html_safe
               css = +"<style>
 #dropper {
   background-color: #eee;
@@ -219,7 +222,7 @@ end %>"
               if ['index', 'show', 'update'].include?(args.first)
                 poly_cols = []
                 css << "<% bts = { #{
-                  bts.each_with_object([]) do |v, s|
+                  bt_items = bts.each_with_object([]) do |v, s|
                     foreign_models = if v.last[2] # Polymorphic?
                                        poly_cols << @_brick_model.reflect_on_association(v[1].first).foreign_type
                                        v.last[1].each_with_object([]) { |x, s| s << "[#{x.name}, #{x.primary_key.inspect}]" }.join(', ')
@@ -227,7 +230,10 @@ end %>"
                                        "[#{v.last[1].name}, #{v.last[1].primary_key.inspect}]"
                                      end
                     s << "#{v.first.inspect} => [#{v.last.first.inspect}, [#{foreign_models}], #{v.last[2].inspect}]"
-                  end.join(', ')
+                  end
+                  # # %%% Need to fix poly going to an STI class
+                  # binding.pry unless poly_cols.empty?
+                  bt_items.join(', ')
                 } }
                 poly_cols = #{poly_cols.inspect} %>"
               end
@@ -261,7 +267,8 @@ if (schemaSelect) {
 
 var tblSelect = document.getElementById(\"tbl\");
 if (tblSelect) {
-  tblSelect.value = changeout(location.href);
+  tblSelect.value = changeout(location.href)[0];
+  if (tblSelect.selectedIndex < 0) tblSelect.value = changeout(location.href)[1];
   tblSelect.addEventListener(\"change\", function () {
     var lhr = changeout(location.href, null, this.value);
     if (brickSchema)
@@ -276,7 +283,8 @@ function changeout(href, param, value) {
     hrefParts = hrefParts[0].split(\"://\");
     var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
     if (value === undefined)
-      return pathParts[1];
+      // A couple possibilities if it's namespaced, starting with two parts in the path -- and then try just one
+      return [pathParts.slice(1, 3).join('/'), pathParts.slice(1, 2)];
     else
       return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
   }
@@ -313,7 +321,7 @@ function changeout(href, param, value) {
       btnImport.style.display = droppedTSV.length > 0 ? \"block\" : \"none\";
     });
     btnImport.addEventListener(\"click\", function () {
-      fetch(changeout(<%= #{obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
+      fetch(changeout(<%= #{path_obj_name}_path(-1, format: :csv).inspect.html_safe %>, \"_brick_schema\", brickSchema), {
         method: 'PATCH',
         headers: { 'Content-Type': 'text/tab-separated-values' },
         body: droppedTSV
@@ -384,17 +392,32 @@ function changeout(href, param, value) {
 <script async defer src=\"https://apis.google.com/js/api.js\" onload=\"gapiLoaded()\"></script>
 "
                          end
+# %%% Instead of our current "for Janet Leverling (Employee)" kind of link we previously had this code that did a "where x = 123" thing:
+#   (where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %>)
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
-<h1>#{model_name.pluralize}</h1>#{template_link}
-
-<% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
+<h1>#{model_plural = model_name.pluralize}</h1>#{template_link}
+
+<% if @_brick_params&.present? %>
+  <% if @_brick_params.length == 1 # %%% Does not yet work with composite keys
+       k, id = @_brick_params.first
+       id = id.first if id.is_a?(Array) && id.length == 1
+       origin = (key_parts = k.split('.')).length == 1 ? #{model_name} : #{model_name}.reflect_on_association(key_parts.first).klass
+      #  binding.pry
+       if (destination_fk = Brick.relations[origin.table_name][:fks].values.find { |fk| puts fk.inspect; 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.name.underscore.tr('/', '_')\}_path\".to_sym, id) %></h3><%
+       end
+     end %>
+  (<%= link_to 'See all #{model_plural.split('::').last}', #{path_obj_name.pluralize}_path %>)
+<% end %>
 <table id=\"#{table_name}\">
   <thead><tr>#{'<th></th>' if pk.present?}
   <% @#{table_name}.columns.map(&:name).each do |col| %>
-    <% next if #{(pk || []).inspect}.include?(col) || ::Brick.config.metadata_columns.include?(col) || poly_cols.include?(col) %>
+    <% next if (#{(pk || []).inspect}.include?(col) && #{model_name}.column_for_attribute(col).type == :integer && !bts.key?(col)) ||
+               ::Brick.config.metadata_columns.include?(col) || poly_cols.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
          BT <%
@@ -407,15 +430,16 @@ function changeout(href, param, value) {
     </th>
   <% end %>
   <%# Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name %>
-  #{hms_headers.map { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.pluralize}_path) %></th>\n" }.join}
+  #{hms_headers.map { |h| "<th>#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>\n" }.join}
   </tr></thead>
 
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
+    <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% #{obj_name}.attributes.each do |k, val| %>
-      <% next if #{(obj_pk || []).inspect}.include?(k) || ::Brick.config.metadata_columns.include?(k) || poly_cols.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && (k.length == 63 || k.end_with?('_ct'))) %>
+      <% next if (#{(obj_pk || []).inspect}.include?(k) && #{model_name}.column_for_attribute(k).type == :integer && !bts.key?(k)) ||
+                 ::Brick.config.metadata_columns.include?(k) || poly_cols.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && (k.length == 63 || k.end_with?('_ct'))) %>
       <td>
       <% if (bt = bts[k]) %>
         <%# binding.pry # Postgres column names are limited to 63 characters %>
@@ -430,7 +454,7 @@ function changeout(href, param, value) {
                #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |z| #{obj_name}.send(z.last[0..62]) }, (bt_id_col = descrips.last)
              )
              bt_id = #{obj_name}.send(*bt_id_col) if bt_id_col&.present? %>
-          <%= bt_id ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
+          <%= bt_id ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
           <%#= Previously was:  bt_obj = bt[1].first.first.find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt[1].first.first.name.underscore\}_path\".to_sym, bt_obj.send(bt[1].first.first.primary_key.to_sym))) if bt_obj %>
         <% end %>
       <% else %>
@@ -440,19 +464,19 @@ function changeout(href, param, value) {
     <% end %>
     #{hms_columns.each_with_object(+'') { |hm_col, s| s << "<td>#{hm_col}</td>" }}
   </tr>
-  </tbody>
   <% end %>
+  </tbody>
 </table>
 
-#{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
+#{"<hr><%= link_to \"New #{obj_name}\", new_#{path_obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
                        when 'show', 'update'
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
-<select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"schema\">#{schema_options}</select>" if ::Brick.config.schema_behavior[:multitenant] && ::Brick.db_schemas.length > 1}
 <select id=\"tbl\">#{table_options}</select>
 <h1>#{model_name}: <%= (obj = @#{obj_name})&.brick_descrip || controller_name %></h1>
-<%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
+<%= link_to '(See all #{obj_name.pluralize})', #{path_obj_name.pluralize}_path %>
 <% if obj %>
   <%= # path_options = [obj.#{pk}]
     # path_options << { '_brick_schema':  } if
@@ -462,7 +486,8 @@ function changeout(href, param, value) {
   <% has_fields = false
     @#{obj_name}.attributes.each do |k, val| %>
     <tr>
-    <% next if #{(pk || []).inspect}.include?(k) || ::Brick.config.metadata_columns.include?(k) %>
+    <% next if (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
+               ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
     <% has_fields = true
       if (bt = bts[k])
@@ -504,7 +529,7 @@ function changeout(href, param, value) {
       html_options = { prompt: \"Select #\{bt_name\}\" }
       html_options[:class] = 'dimmed' unless val %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
-      <%= bt_obj = bt_class&.find_by(bt_pair[1] => val); link_to('⇛', send(\"#\{bt_class.base_class.name.underscore\}_path\".to_sym, bt_obj.send(bt_class.primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+      <%= 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' }) if bt_obj %>
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
@@ -546,7 +571,7 @@ function changeout(href, param, value) {
           <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}_path([#{obj_pk}])) %></td></tr>
+            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore.tr('/', '_')}_path([#{obj_pk}])) %></td></tr>
           <% end %>
         <% end %>
       </table>"

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -90,7 +90,7 @@ module Brick
   end
 
   class << self
-    attr_accessor :db_schemas
+    attr_accessor :default_schema, :db_schemas
 
     def set_db_schema(params)
       schema = params['_brick_schema'] || 'public'
@@ -99,10 +99,13 @@ module Brick
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
     def relations
-      connections = Brick.instance_variable_get(:@relations) ||
-        Brick.instance_variable_set(:@relations, (connections = {}))
       # Key our list of relations for this connection off of the connection pool's object_id
-      (connections[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } })
+      (@relations ||= {})[ActiveRecord::Base.connection_pool.object_id] ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }
+    end
+
+    # If multitenancy is enabled, a list of non-tenanted "global" models
+    def non_tenanted_models
+      @pending_models ||= {}
     end
 
     def get_bts_and_hms(model)
@@ -287,8 +290,16 @@ module Brick
     # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes
     # for polymorphics in which it wasn't originally specified.
     # @api public
-    def schema_to_analyse=(schema)
-      Brick.config.schema_to_analyse = schema
+    def schema_behavior=(behavior)
+      Brick.config.schema_behavior = (behavior.is_a?(Symbol) ? { behavior => nil } : behavior)
+    end
+    # For any Brits out there
+    def schema_behaviour=(behavior)
+      Brick.schema_behavior = behavior
+    end
+
+    def sti_type_column=(type_col)
+      Brick.config.sti_type_column = (type_col.is_a?(String) ? { type_col => nil } : type_col)
     end
 
     def default_route_fallback=(resource_name)
@@ -303,18 +314,23 @@ module Brick
 
       relations = ::Brick.relations
       if (ars = ::Brick.config.additional_references) || ::Brick.config.polymorphics
-        ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2], relations) } if ars
+        if ars
+          ars.each do |ar|
+            fk = ar.length < 5 ? [nil, +ar[0], ar[1], nil, +ar[2]] : [ar[0], +ar[1], ar[2], ar[3], +ar[4], ar[5]]
+            ::Brick._add_bt_and_hm(fk, relations, false, true)
+          end
+        end
         if (polys = ::Brick.config.polymorphics)
-          if (schema = ::Brick.config.schema_to_analyse) && ::Brick.db_schemas&.include?(schema)
+          if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
           end
           missing_stis = {}
           polys.each do |k, v|
             table_name, poly = k.split('.')
-            v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").map { |result| result['typ'] }
+            v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").each_with_object([]) { |result, s| s << result['typ'] if result['typ'] }
             v.each do |type|
               if relations.key?(primary_table = type.underscore.pluralize)
-                ::Brick._add_bt_and_hm([table_name, poly, primary_table, "(brick) #{table_name}_#{poly}"], relations, true)
+                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations, true, true)
               else
                 missing_stis[primary_table] = type unless ::Brick.existing_stis.key?(type)
               end
@@ -390,11 +406,20 @@ In config/initializers/brick.rb appropriate entries would look something like:
         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:
-        ::Brick.relations.each do |k, v|
-          unless existing_controllers.key?(controller_name = k.underscore.pluralize)
+        ::Brick.relations.each do |rel_name, v|
+          rel_name = rel_name.split('.').map(&:underscore)
+          schema_names = rel_name[0..-2]
+          k = rel_name.last
+          unless existing_controllers.key?(controller_name = k.pluralize)
             options = {}
             options[:only] = [:index, :show] if v.key?(:isView)
-            send(:resources, controller_name.to_sym, **options)
+            if schema_names.present? # && !Object.const_defined('Apartment')
+              send(:namespace, schema_names.first) do
+                send(:resources, controller_name.to_sym, **options)
+              end
+            else
+              send(:resources, controller_name.to_sym, **options)
+            end
           end
         end
       end

data/lib/generators/brick/install_generator.rb

@@ -215,9 +215,15 @@ module Brick
 # Brick.sti_namespace_prefixes = { '::Animals::' => 'Animal',
 #                                  '::Snake' => 'Reptile' }
 
+# # Custom inheritance_column to be used for STI.  This is by default \"type\", and applies to all models.  With this
+# # option you can change this either for specific models, or apply a new overall name generally:
+# Brick.sti_type_column = 'sti_type'
+# Brick.sti_type_column = { 'rails_type' => ['sales.specialoffer'] }
+
 # # Database schema to use when analysing existing data, such as deriving a list of polymorphic classes in the case that
 # # it wasn't originally specified.
-# Brick.schema_to_analyse = 'engineering'
+# Brick.schema_behavior = :namespaced
+# Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering' } }
 
 # # Polymorphic associations are set up by providing a model name and polymorphic association name#{poly}
 

metadata

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