brick 1.0.32 → 1.0.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8483d9a50013e440cce28f648d09d5322985702f952520cb83c69ad0e5742ce4
-  data.tar.gz: 40072d0504f4d2b1cc9a59e62fef305b939dd977da0e794445adf003dbfb8b7e
+  metadata.gz: 34a23d1057771acea1beb9ea1ea2ff3d27e5983084bcd47f4c87686af77328d5
+  data.tar.gz: 44aea0d5fb92a361913ba4a17ebca62cf5be9aca5585fa9785b7c388c2652cee
 SHA512:
-  metadata.gz: 9740778159acb464652322ef36eff763a55b38c6579fe0a7550a5797db44928ad6832a8bccc0d924a4d4c5a14dc02658e61bf4220cecff08fc348d540b67e41c
-  data.tar.gz: 1b09db07a284512821b604f1d82f64c4be0c11db7f8a8973f36ab3f78b21804a7fec1eb641bcf1ac5c2ec118cb477c8086c124017c66550753ec4f9beddbd413
+  metadata.gz: e9124cbd0db47816db2dcbf59a76adcc0d4dcaea8f4ad02ea9ee99aace025c8914a7871c78a4a703f4daeced7dbaec12d52fdf56b6bc131c4c855be931d4f838
+  data.tar.gz: 671d0333b9a89870db67cdec05306311475724d674aab494c794baa0648736c873ea2aade170bdbc51642b96e4fe76a19f568bf31e724bd513230e1a78c69521

data/lib/brick/compatibility.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_record/version'
+
+# ActiveRecord before 4.0 didn't have #version
+unless ActiveRecord.respond_to?(:version)
+  module ActiveRecord
+    def self.version
+      ::Gem::Version.new(ActiveRecord::VERSION::STRING)
+    end
+  end
+end
+
+# In ActiveSupport older than 5.0, the duplicable? test tries to new up a BigDecimal,
+# and Ruby 2.6 and later deprecates #new.  This removes the warning from BigDecimal.
+# This compatibility needs to be put into place in the application's "config/boot.rb"
+# file by having the line "require 'brick/compatibility'" to be the last line in that
+# file.
+require 'bigdecimal'
+if ::Gem::Version.new(RUBY_VERSION) >= ::Gem::Version.new('2.6') &&
+   ActiveRecord.version < ::Gem::Version.new('5.0')
+  def BigDecimal.new(*args, **kwargs)
+    BigDecimal(*args, **kwargs)
+  end
+end

data/lib/brick/extensions.rb

@@ -86,7 +86,11 @@ module ActiveRecord
         descrip_col = (columns.map(&:name) - _brick_get_fks -
                       (::Brick.config.metadata_columns || []) -
                       [primary_key]).first
-        dsl = ::Brick.config.model_descrips[name] = "[#{descrip_col}]" if descrip_col
+        dsl = ::Brick.config.model_descrips[name] = if descrip_col
+                                                      "[#{descrip_col}]"
+                                                    elsif (pk_parts = self.primary_key.is_a?(Array) ? self.primary_key : [self.primary_key])
+                                                      "#{name} ##{pk_parts.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
+                                                    end
       end
       dsl
     end
@@ -129,7 +133,7 @@ module ActiveRecord
         end
       else # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
         x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
-        x[prefix[-1]] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
+        x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
       members
     end
@@ -159,6 +163,7 @@ module ActiveRecord
                         bracket_name.split('.').each do |part|
                           obj_name += ".#{part}"
                           this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
+                          break if this_obj.nil?
                         end
                         this_obj&.to_s || ''
                       end
@@ -198,7 +203,9 @@ module ActiveRecord
       model_underscore = name.underscore
       assoc_name = CGI.escapeHTML(assoc_name.to_s)
       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)
+      av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
+      av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('6.1')
+      link = av_class.link_to(name, model_path)
       model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
     end
 
@@ -252,13 +259,12 @@ module ActiveRecord
           names << [piece.right._arel_table_type, (piece.right.table_alias || piece.right.name)]
         else # "Normal" setup, fed from a JoinSource which has an array of JOINs
           # The left side is the "JOIN" table
-          names += _recurse_arel(piece.left)
+          names += _recurse_arel(table = piece.left)
           # The expression on the right side is the "ON" clause
           # on = piece.right.expr
           # # Find the table which is not ourselves, and thus must be the "path" that led us here
           # parent = piece.left == on.left.relation ? on.right.relation : on.left.relation
           # binding.pry if piece.left.is_a?(Arel::Nodes::TableAlias)
-          table = piece.left
           if table.is_a?(Arel::Nodes::TableAlias)
             alias_name = table.right
             table = table.left
@@ -277,7 +283,8 @@ module ActiveRecord
         @_brick_chains = {}
         # The left side is the "FROM" table
         # names += _recurse_arel(piece.left)
-        names << [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)]
+        names << (this_name = [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)])
+        (_brick_chains[this_name.first] ||= []) << this_name.last
         # The right side is an array of all JOINs
         piece.right.each { |join| names << _recurse_arel(join) }
       end
@@ -304,6 +311,23 @@ module ActiveRecord
       # , is_add_bts, is_add_hms
     )
       is_add_bts = is_add_hms = true
+      is_distinct = nil
+      wheres = {}
+      params.each do |k, v|
+        case (ks = k.split('.')).length
+        when 1
+          next unless klass._brick_get_fks.include?(k)
+        when 2
+          assoc_name = ks.first.to_sym
+          # Make sure it's a good association name and that the model has that column name
+          next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(ks.last)
+
+          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
+          is_distinct = true
+          distinct!
+        end
+        wheres[k] = v.split(',')
+      end
 
       # %%% Skip the metadata columns
       if selects&.empty? # Default to all columns
@@ -312,7 +336,9 @@ module ActiveRecord
           if (col_name = col.name) == 'class'
             col_alias = ' AS _class'
           end
-          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{col_alias}"
+          # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
+          cast_as_text = '::text' if is_distinct && Brick.relations[klass.table_name]&.[](:cols)&.[](col.name)&.first&.start_with?('xml')
+          selects << "\"#{tbl_no_schema}\".\"#{col_name}\"#{cast_as_text}#{col_alias}"
         end
       end
 
@@ -338,22 +364,6 @@ module ActiveRecord
         end
       end
 
-      wheres = {}
-      params.each do |k, v|
-        case (ks = k.split('.')).length
-        when 1
-          next unless klass._brick_get_fks.include?(k)
-        when 2
-          assoc_name = ks.first.to_sym
-          # Make sure it's a good association name and that the model has that column name
-          next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(ks.last)
-
-          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)
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
@@ -371,7 +381,9 @@ module ActiveRecord
             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])).split('.').last
 
-              selects << "#{"\"#{field_tbl_name}\".\"#{sel_col.last}\""} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
+              # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
+              is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
+              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
               v1[idx] << col_alias
             end
 
@@ -489,8 +501,9 @@ 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
-        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_name = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil))
+          base_class_name = "::#{base_class_name}" unless base_class_name.start_with?('::')
+        end
         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
@@ -548,7 +561,7 @@ Module.class_exec do
                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 (plural_class_name == 'BrickSwagger' || 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
@@ -566,11 +579,13 @@ Module.class_exec do
                [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?
+               # Custom inheritable Brick base model?
+               class_name = (inheritable_name = class_name)[5..-1] if class_name.start_with?('Brick')
                # 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?
+               if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+                  self != Object # ... or otherwise already in some namespace?
                  schema_name = [(singular_schema_name = name.underscore),
                                 (schema_name = singular_schema_name.pluralize),
                                 name,
@@ -583,7 +598,7 @@ Module.class_exec do
                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)
+                 Object.send(:build_model, self, inheritable_name, 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.
@@ -592,10 +607,13 @@ Module.class_exec do
                               else
                                 ActiveSupport::Inflector.pluralize(singular_table_name)
                               end
-
+                 if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') &&
+                    Apartment.excluded_models.include?(table_name.singularize.camelize)
+                   schema_name = Apartment.default_schema
+                 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?(schema_name ? "#{schema_name}.#{m}" : m) })
-                   Object.send(:build_model, schema_name, model_name, singular_table_name, table_name, relations, matching)
+                   Object.send(:build_model, schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
                  end
                end
              end
@@ -623,9 +641,12 @@ class Object
 
   private
 
-    def build_model(schema_name, model_name, singular_table_name, table_name, relations, matching)
-      full_name = if schema_name.blank?
-                    model_name
+    def build_model(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
+      full_name = if (::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && schema_name == Apartment.default_schema)
+                    relation = relations["#{schema_name}.#{matching}"]
+                    inheritable_name || model_name
+                  elsif schema_name.blank?
+                    inheritable_name || 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
@@ -633,21 +654,23 @@ class Object
                                       matching = "#{schema_name}.#{matching}"
                                       (Brick.db_schemas[schema_name] ||= self.const_get(schema_name.singularize.camelize))
                                     end
-                    "#{schema_module&.name}::#{model_name}"
+                    "#{schema_module&.name}::#{inheritable_name || model_name}"
                   end
 
-      return if ((is_view = (relation = relations[matching]).key?(:isView)) && ::Brick.config.skip_database_views) ||
+      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.camelize}::")
-          puts "Warning: Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\"."
+          puts "Warning: Class name for a model that references table \"#{matching
+               }\" should be \"#{ActiveSupport::Inflector.singularize(inheritable_name || model_name)}\"."
         end
         return
       end
 
-      if (base_model = ::Brick.sti_models[full_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_name]&.constantize)
+      full_model_name = full_name.split('::').tap { |fn| fn[-1] = model_name }.join('::')
+      if (base_model = ::Brick.sti_models[full_model_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_model_name]&.constantize)
         is_sti = true
       else
         base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
@@ -655,9 +678,21 @@ class Object
       hmts = nil
       code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
-        (schema_module || Object).const_set(model_name.to_sym, new_model_class)
+        (schema_module || Object).const_set((inheritable_name || model_name).to_sym, new_model_class)
+        if inheritable_name
+          new_model_class.define_singleton_method :inherited do |subclass|
+            super(subclass)
+            if subclass.name == model_name
+              puts "#{full_model_name} properly extends from #{full_name}"
+            else
+              puts "should be \"class #{model_name} < #{inheritable_name}\"\n           (not \"#{subclass.name} < #{inheritable_name}\")"
+            end
+          end
+          self.abstract_class = true
+          code << "  self.abstract_class = true\n"
+        end
         # 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
+        code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || table_name != matching
 
         # Override models backed by a view so they return true for #is_view?
         # (Dynamically-created controllers and view templates for such models will then act in a read-only way)
@@ -685,6 +720,9 @@ class Object
             code << "  self.primary_key = #{pk_sym.inspect}\n"
           end
           _brick_primary_key(relation) # Set the newly-found PK in the instance variable
+        elsif (possible_pk = ActiveRecord::Base.get_primary_key(base_class.name)) && relation[:cols][possible_pk]
+          new_model_class.primary_key = (possible_pk = possible_pk.to_sym)
+          code << "  self.primary_key = #{possible_pk.inspect}\n"
         else
           code << "  # Could not identify any column(s) to use as a primary key\n" unless is_view
         end
@@ -725,7 +763,8 @@ class Object
           hmts&.each do |hmt_fk, fks|
             hmt_fk = hmt_fk.tr('.', '_')
             fks.each do |fk|
-              through = fk.first[:assoc_name]
+              # %%% Will not work with custom has_many name
+              through = ::Brick.config.schema_behavior[:multitenant] ? fk.first[:assoc_name] : fk.first[:inverse_table].tr('.', '_').pluralize
               hmt_name = if fks.length > 1
                            if fks[0].first[:inverse][:assoc_name] == fks[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
                              "#{hmt_fk}_through_#{fk.first[:assoc_name]}"
@@ -740,8 +779,12 @@ class Object
               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
+                # Was:
+                # options[:class_name] = fk.first[:inverse_table].singularize.camelize
+                # options[:foreign_key] = fk.first[:fk].to_sym
+                far_assoc = relations[fk.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == fk.last }
+                options[:class_name] = far_assoc.last[:inverse_table].singularize.camelize
+                options[:foreign_key] = far_assoc.last[: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"
@@ -843,19 +886,70 @@ class Object
     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))
+      pk = model&._brick_primary_key(relations.fetch(table_name, nil))
 
       namespace_name = "#{namespace.name}::" if namespace
       code = +"class #{namespace_name}#{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)
 
-        code << "  def index\n"
-        code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
-        code << "    @#{table_name}.brick_select(params)\n"
-        code << "  end\n"
+        unless (is_swagger = plural_class_name == 'BrickSwagger') # && request.format == :json)
+          code << "  def index\n"
+          code << "    @#{table_name} = #{model.name}#{pk&.present? ? ".order(#{pk.inspect})" : '.all'}\n"
+          code << "    @#{table_name}.brick_select(params)\n"
+          code << "  end\n"
+        end
         self.protect_from_forgery unless: -> { self.request.format.js? }
         self.define_method :index do
+          if is_swagger
+            json = { 'openapi': '3.0.1', 'info': { 'title': 'API V1', 'version': 'v1' },
+                     'servers': [
+                       { 'url': 'https://{defaultHost}', 'variables': { 'defaultHost': { 'default': 'www.example.com' } } }
+                     ]
+                   }
+            json['paths'] = relations.inject({}) do |s, v|
+              s["/api/v1/#{v.first}"] = {
+                'get': {
+                  'summary': "list #{v.first}",
+                  'parameters': v.last[:cols].map { |k, v| { 'name' => k, 'schema': { 'type': v.first } } },
+                  'responses': { '200': { 'description': 'successful' } }
+                }
+              }
+              # next if v.last[:isView]
+
+              s["/api/v1/#{v.first}/{id}"] = {
+                'patch': {
+                  'summary': "update a #{v.first.singularize}",
+                  'parameters': v.last[:cols].reject { |k, v| Brick.config.metadata_columns.include?(k) }.map do |k, v|
+                    { 'name' => k, 'schema': { 'type': v.first } }
+                  end,
+                  'responses': { '200': { 'description': 'successful' } }
+                }
+                # "/api/v1/books/{id}": {
+                #   "parameters": [
+                #     {
+                #       "name": "id",
+                #       "in": "path",
+                #       "description": "id",
+                #       "required": true,
+                #       "schema": {
+                #         "type": "string"
+                #       }
+                #     },
+                #     {
+                #       "name": "Authorization",
+                #       "in": "header",
+                #       "schema": {
+                #         "type": "string"
+                #       }
+                #     }
+                #   ],
+              }
+              s
+            end
+            render inline: json.to_json, content_type: request.format
+            return
+          end
           ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
@@ -869,7 +963,8 @@ class Object
             return
           end
 
-          order = pk.each_with_object([]) { |pk_part, s| s << "#{model.table_name}.#{pk_part}" }
+          quoted_table_name = model.table_name.split('.').map { |x| "\"#{x}\"" }.join('.')
+          order = pk.each_with_object([]) { |pk_part, s| s << "#{quoted_table_name}.\"#{pk_part}\"" }
           ar_relation = order.present? ? model.order("#{order.join(', ')}") : model.all
           @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
           # %%% Add custom HM count columns
@@ -884,7 +979,8 @@ class Object
           @_brick_join_array = join_array
         end
 
-        if model.primary_key
+        is_pk_string = nil
+        if (pk_col = model&.primary_key)
           code << "  def show\n"
           code << (find_by_id = "    id = params[:id]&.split(/[\\/,_]/)
     id = id.first if id.is_a?(Array) && id.length == 1
@@ -892,14 +988,19 @@ class Object
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
-            id = params[:id]&.split(/[\/,_]/)
+            id = if model.columns_hash[pk_col]&.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, model.find(id))
           end
         end
 
         # By default, views get marked as read-only
-        unless false # model.readonly # (relation = relations[model.table_name]).key?(:isView)
+        unless is_swagger # model.readonly # (relation = relations[model.table_name]).key?(:isView)
           code << "  # (Define :new, :create)\n"
 
           if model.primary_key
@@ -931,7 +1032,7 @@ class Object
               #   return
               end
 
-              id = params[:id]&.split(/[\/,_]/)
+              id = is_pk_string ? params[: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)
@@ -957,11 +1058,20 @@ class Object
     end
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
-      if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
+      if (relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1) &&
+         hm_assoc[:alternate_name] != hm_assoc[:inverse][:assoc_name]
         plural = ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])
-        [hm_assoc[:alternate_name] == name.underscore ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural, true]
+        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 = hm_assoc[:inverse_table].pluralize
+        # hm_assoc[:assoc_name] = assoc_name
         [assoc_name, assoc_name.include?('.')]
       end
     end
@@ -989,6 +1099,12 @@ module ActiveRecord::ConnectionHandling
       if File.exist?(brick_initializer = Rails.root.join('config/initializers/brick.rb'))
         initializer_loaded = load brick_initializer
       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
+      if Object.const_defined?('Apartment') && File.exist?(apartment_initializer = Rails.root.join('config/initializers/apartment.rb'))
+        load apartment_initializer
+        apartment_excluded = Apartment.excluded_models
+      end
       # Only for Postgres?  (Doesn't work in sqlite3)
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
@@ -1004,12 +1120,14 @@ module ActiveRecord::ConnectionHandling
       when 'Mysql2'
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
       when 'SQLite'
+        # %%% Retrieve internal ActiveRecord table names like this:
+        # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
         sql = "SELECT m.name AS relation_name, UPPER(m.type) AS table_type,
           p.name AS column_name, p.type AS data_type,
           CASE p.pk WHEN 1 THEN 'PRIMARY KEY' END AS const
         FROM sqlite_master AS m
           INNER JOIN pragma_table_info(m.name) AS p
-        WHERE m.name NOT IN ('ar_internal_metadata', 'schema_migrations')
+        WHERE m.name NOT IN (?, ?)
         ORDER BY m.name, p.cid"
       else
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
@@ -1037,6 +1155,9 @@ module ActiveRecord::ConnectionHandling
         end
       end
 
+      # %%% Retrieve internal ActiveRecord table names like this:
+      # ActiveRecord::Base.internal_metadata_table_name, ActiveRecord::Base.schema_migrations_table_name
+      # For if it's not SQLite -- so this is the Postgres and MySQL version
       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,
@@ -1058,18 +1179,22 @@ module ActiveRecord::ConnectionHandling
         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')
+          AND t.table_name NOT IN ('pg_stat_statements', ?, ?)
         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|
-          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
+        ar_imtn = ActiveRecord.version >= ::Gem::Version.new('5.0') ? ActiveRecord::Base.internal_metadata_table_name : ''
+        ActiveRecord::Base.execute_sql(sql, ActiveRecord::Base.schema_migrations_table_name, ar_imtn).each do |r|
+          # If Apartment gem lists the table as being associated with a non-tenanted model then use whatever it thinks
+          # is the default schema, usually 'public'.
+          schema_name = if ::Brick.config.schema_behavior[:multitenant]
+                          Apartment.default_schema if apartment_excluded&.include?(r['relation_name'].singularize.camelize)
+                        elsif ![schema, 'public'].include?(r['schema'])
+                          r['schema']
+                        end
+          relation_name = schema_name ? "#{schema_name}.#{r['relation_name']}" : r['relation_name']
           relation = relations[relation_name]
           relation[:isView] = true if r['table_type'] == 'VIEW'
           col_name = r['column_name']
@@ -1154,19 +1279,41 @@ module ActiveRecord::ConnectionHandling
         # ::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)
+          # Multitenancy makes things a little more general overall, except for non-tenanted tables
+          if apartment_excluded&.include?(fk[1].singularize.camelize)
+            fk[0] = Apartment.default_schema
+          elsif fk[0] == 'public' || (is_multitenant && fk[0] == schema)
+            fk[0] = nil
+          end
+          if apartment_excluded&.include?(fk[4].singularize.camelize)
+            fk[3] = Apartment.default_schema
+          elsif fk[3] == 'public' || (is_multitenant && fk[3] == schema)
+            fk[3] = nil
+          end
           ::Brick._add_bt_and_hm(fk, relations)
         end
       end
     end
 
-    puts "\nClasses that can be built from tables:"
-    relations.select { |_k, v| !v.key?(:isView) }.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
-    unless (views = relations.select { |_k, v| v.key?(:isView) }).empty?
+    apartment = Object.const_defined?('Apartment') && Apartment
+    tables = []
+    views = []
+    relations.each do |k, v|
+      name_parts = k.split('.')
+      if v.key?(:isView)
+        views
+      else
+        name_parts.shift if apartment && name_parts.length > 1 && name_parts.first == Apartment.default_schema
+        tables
+      end << name_parts.map { |x| x.singularize.camelize }.join('::')
+    end
+    unless tables.empty?
+      puts "\nClasses that can be built from tables:"
+      tables.sort.each { |x| puts x }
+    end
+    unless views.empty?
       puts "\nClasses that can be built from views:"
-      views.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
+      views.sort.each { |x| puts x }
     end
 
     ::Brick.load_additional_references if initializer_loaded
@@ -1209,16 +1356,31 @@ module Brick
       end
       # %%% Temporary schema patch
       for_tbl = fk[1]
+      apartment = Object.const_defined?('Apartment') && Apartment
+      fk[0] = Apartment.default_schema if apartment && apartment.excluded_models.include?(for_tbl.singularize.camelize)
       fk[1] = "#{fk[0]}.#{fk[1]}" if fk[0] # && fk[0] != ::Brick.default_schema
       bts = (relation = relations.fetch(fk[1], nil))&.fetch(:fks) { relation[:fks] = {} }
+
       # %%% 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 = if (is_class = fk[4].is_a?(Hash) && fk[4].key?(:class))
                         pri_tbl = (primary_class = fk[4][:class].constantize).table_name
+                        if (pri_tbl_parts = pri_tbl.split('.')).length > 1
+                          fk[3] = pri_tbl_parts.first
+                        end
                       else
-                        is_schema = fk[3] != ::Brick.default_schema && (::Brick.config.schema_behavior[:multitenant] || fk[3] != 'public')
+                        is_schema = if ::Brick.config.schema_behavior[:multitenant]
+                                      # If Apartment gem lists the primary table as being associated with a non-tenanted model
+                                      # then use 'public' schema for the primary table
+                                      if apartment && apartment&.excluded_models.include?(fk[4].singularize.camelize)
+                                        fk[3] = Apartment.default_schema
+                                        true
+                                      end
+                                    else
+                                      fk[3] && fk[3] != ::Brick.default_schema && fk[3] != 'public'
+                                    end
                         pri_tbl = fk[4]
-                        fk[3] && is_schema ? "#{fk[3]}.#{pri_tbl}" : pri_tbl
+                        is_schema ? "#{fk[3]}.#{pri_tbl}" : pri_tbl
                       end
       hms = (relation = relations.fetch(primary_table, nil))&.fetch(:fks) { relation[:fks] = {} } unless is_class
 
@@ -1287,7 +1449,13 @@ module Brick
         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[2], assoc_name: for_tbl.pluralize, alternate_name: bt_assoc_name, inverse_table: fk[1], inverse: assoc_bt }
+        inv_tbl = if ::Brick.config.schema_behavior[:multitenant] && apartment && fk[0] == Apartment.default_schema
+                    for_tbl
+                  else
+                    fk[1]
+                  end
+        assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: for_tbl.pluralize, alternate_name: bt_assoc_name,
+                                          inverse_table: inv_tbl, inverse: assoc_bt }
         assoc_hm[:polymorphic] = true if is_polymorphic
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1

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

@@ -124,8 +124,15 @@ module Brick
               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).sort
-                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>" }.html_safe
+              apartment_default_schema = ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && Apartment.default_schema
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).map do |tbl|
+                                if (tbl_parts = tbl.split('.')).first == apartment_default_schema
+                                  tbl = tbl_parts.last
+                                end
+                                tbl
+                              end.sort.each_with_object(+'') do |v, s|
+                                s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
+                              end.html_safe
               css = +"<style>
 #dropper {
   background-color: #eee;
@@ -209,12 +216,17 @@ input[type=submit] {
 <% def is_bcrypt?(val)
   val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
 end
-def hide_bcrypt(val)
+def hide_bcrypt(val, max_len = 200)
   if is_bcrypt?(val)
     '(hidden)'
-  elsif val.is_a?(String) && val.encoding.name != 'UTF-8'
-    val[0..1000].force_encoding('UTF-8')
   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'
+    end
     val
   end
 end %>"
@@ -238,46 +250,51 @@ end %>"
                 poly_cols = #{poly_cols.inspect} %>"
               end
 
-              # %%% When doing schema select, if there's an ID then remove it, or if we're on a new page go to index
+              # %%% When doing schema select, if we're on a new page go to index
               script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
+var tblSelect = document.getElementById(\"tbl\");
 var brickSchema;
-if (schemaSelect) {
-  brickSchema = changeout(location.href, \"_brick_schema\");
-  if (brickSchema) {
-    [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
+
+// This PageTransitionEvent fires when the page first loads, as well as after any other history
+// transition such as when using the browser's Back and Forward buttons.
+window.addEventListener(\"pageshow\", function() {
+  if (schemaSelect) { // First drop-down is only present if multitenant
+    brickSchema = changeout(location.href, \"_brick_schema\");
+    if (brickSchema) {
+      [... document.getElementsByTagName(\"A\")].forEach(function (a) { a.href = changeout(a.href, \"_brick_schema\", brickSchema); });
+    }
+    schemaSelect.value = brickSchema || \"public\";
+    schemaSelect.focus();
+    schemaSelect.addEventListener(\"change\", function () {
+      // If there's an ID then remove it (trim after selected table)
+      location.href = changeout(location.href, \"_brick_schema\", this.value, tblSelect.value);
+    });
   }
-  schemaSelect.value = brickSchema || \"public\";
-  schemaSelect.focus();
-  schemaSelect.addEventListener(\"change\", function () {
-    location.href = changeout(location.href, \"_brick_schema\", this.value);
-  });
-}
-[... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
-  if (brickSchema)
-    form.action = changeout(form.action, \"_brick_schema\", brickSchema);
-  form.addEventListener('submit', function (ev) {
-    [... ev.target.getElementsByTagName(\"SELECT\")].forEach(function (select) {
-      if (select.value === \"^^^brick_NULL^^^\")
-        select.value = null;
+  [... document.getElementsByTagName(\"FORM\")].forEach(function (form) {
+    if (brickSchema)
+      form.action = changeout(form.action, \"_brick_schema\", brickSchema);
+    form.addEventListener('submit', function (ev) {
+      [... ev.target.getElementsByTagName(\"SELECT\")].forEach(function (select) {
+        if (select.value === \"^^^brick_NULL^^^\")
+          select.value = null;
+      });
+      return true;
     });
-    return true;
   });
-});
 
-var tblSelect = document.getElementById(\"tbl\");
-if (tblSelect) {
-  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)
-      lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
-    location.href = lhr;
-  });
-}
+  if (tblSelect) { // Always present
+    tblSelect.value = changeout(location.href)[schemaSelect ? 1 : 0];
+    tblSelect.addEventListener(\"change\", function () {
+      var lhr = changeout(location.href, null, this.value);
+      if (brickSchema)
+        lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
+      location.href = lhr;
+    });
+  }
+});
 
-function changeout(href, param, value) {
+function changeout(href, param, value, trimAfter) {
   var hrefParts = href.split(\"?\");
   if (param === undefined || param === null) {
     hrefParts = hrefParts[0].split(\"://\");
@@ -288,6 +305,11 @@ function changeout(href, param, value) {
     else
       return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
   }
+  if (trimAfter) {
+    var pathParts = hrefParts[0].split(\"/\");
+    while (pathParts.lastIndexOf(trimAfter) != pathParts.length - 1) pathParts.pop();
+    hrefParts[0] = pathParts.join(\"/\");
+  }
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
   params = params.reduce(function (s, v) { var parts = v.split(\"=\"); s[parts[0]] = parts[1]; return s; }, {});
   if (value === undefined) return params[param];
@@ -353,7 +375,6 @@ function changeout(href, param, value) {
 
   async function updateSignInStatus(isSignedIn) {
     if (isSignedIn) {
-      console.log(\"turds!\");
       await gapi.client.sheets.spreadsheets.create({
         properties: {
           title: #{table_name.inspect},
@@ -407,7 +428,7 @@ function changeout(href, param, value) {
        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)) %>
+          (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 %>
@@ -442,7 +463,6 @@ function changeout(href, param, value) {
                  ::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 %>
         <% 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
@@ -451,6 +471,7 @@ function changeout(href, param, value) {
                            send(\"#\{base_class\}_path\".to_sym, poly_id)) if poly_id %><%
            else
              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 { |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? %>
@@ -533,7 +554,7 @@ function changeout(href, param, value) {
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
-          <%= hide_bcrypt(val) %>
+          <%= hide_bcrypt(val, 1000) %>
         <% else %>
           <div class=\"wide-input\"><%= f.text_field k.to_sym %></div>
         <% end %>
@@ -566,7 +587,7 @@ function changeout(href, param, value) {
       s << "<table id=\"#{hm_name}\">
         <tr><th>#{hm[3]}</th></tr>
         <% collection = @#{obj_name}.#{hm_name}
-        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
+        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection].compact
         if collection.empty? %>
           <tr><td>(none)</td></tr>
         <% else %>
@@ -600,6 +621,7 @@ function changeout(href, param, value) {
 
         # Just in case it hadn't been done previously when we tried to load the brick initialiser,
         # go make sure we've loaded additional references (virtual foreign keys and polymorphic associations).
+        # (This should only happen if for whatever reason the initializer file was not exactly config/initializers/brick.rb.)
         ::Brick.load_additional_references
       end
     end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -1,25 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_record/version'
-
-# ActiveRecord before 4.0 didn't have #version
-unless ActiveRecord.respond_to?(:version)
-  module ActiveRecord
-    def self.version
-      ::Gem::Version.new(ActiveRecord::VERSION::STRING)
-    end
-  end
-end
-
-# In ActiveSupport older than 5.0, the duplicable? test tries to new up a BigDecimal,
-# and Ruby 2.6 and later deprecates #new.  This removes the warning from BigDecimal.
-require 'bigdecimal'
-if (ruby_version = ::Gem::Version.new(RUBY_VERSION)) >= ::Gem::Version.new('2.6') &&
-   ActiveRecord.version < ::Gem::Version.new('5.0')
-  def BigDecimal.new(*args, **kwargs)
-    BigDecimal(*args, **kwargs)
-  end
-end
+require 'brick/compatibility'
 
 # Allow ActiveRecord 4.0 and 4.1 to work with newer Ruby (>= 2.4) by avoiding a "stack level too deep"
 # error when ActiveSupport tries to smarten up Numeric by messing with Fixnum and Bignum at the end of:
@@ -45,8 +26,8 @@ end
 require 'brick/util'
 
 # Allow ActiveRecord < 3.2 to work with Ruby 2.7 and later
-if ActiveRecord.version < ::Gem::Version.new('3.2') &&
-   ruby_version >= ::Gem::Version.new('2.7')
+if (ruby_version = ::Gem::Version.new(RUBY_VERSION)) >= ::Gem::Version.new('2.7') &&
+   ActiveRecord.version < ::Gem::Version.new('3.2')
   # Remove circular reference for "now"
   ::Brick::Util._patch_require(
     'active_support/values/time_zone.rb', '/activesupport',
@@ -409,6 +390,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
         ::Brick.relations.each do |rel_name, v|
           rel_name = rel_name.split('.').map(&:underscore)
           schema_names = rel_name[0..-2]
+          schema_names.shift if ::Brick.config.schema_behavior[:multitenant] && Object.const_defined?('Apartment') && schema_names.first == Apartment.default_schema
           k = rel_name.last
           unless existing_controllers.key?(controller_name = k.pluralize)
             options = {}
@@ -422,6 +404,7 @@ In config/initializers/brick.rb appropriate entries would look something like:
             end
           end
         end
+        send(:get, '/api-docs/v1/swagger.json', { to: 'brick_swagger#index' }) if Object.const_defined?('Rswag::Ui')
       end
       super
     end

data/lib/generators/brick/install_generator.rb

@@ -18,7 +18,8 @@ module Brick
     desc 'Generates an initializer file for configuring Brick'
 
     def create_initializer_file
-      unless File.exist?(filename = 'config/initializers/brick.rb')
+      is_brick_file = File.exist?(filename = 'config/initializers/brick.rb')
+      if is_brick_file && ::Brick.config.schema_behavior[:multitenant] || !is_brick_file
         # See if we can make suggestions for additional_references and polymorphic associations
         resembles_fks = Hash.new { |h, k| h[k] = [] }
         possible_polymorphics = {}
@@ -28,7 +29,7 @@ module Brick
             col_down = col.downcase
 
             if (is_possible_poly = ['character varying', 'text'].include?(type.first))
-              if col_down.end_with?('_type') &&
+              if col_down.end_with?('_type')
                 poly_type_cut_length = -6
                 col_down = col_down[0..-6]
               elsif col_down.end_with?('type')
@@ -223,7 +224,10 @@ module Brick
 # # 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_behavior = :namespaced
-# Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering' } }
+#{Brick.config.schema_behavior ? "Brick.schema_behavior = { multitenant: { schema_to_analyse: #{
+  Brick.config.schema_behavior[:multitenant][:schema_to_analyse].inspect}" :
+"# 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.32
+  version: 1.0.35
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-08 00:00:00.000000000 Z
+date: 2022-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -214,6 +214,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/brick.rb
+- lib/brick/compatibility.rb
 - lib/brick/config.rb
 - lib/brick/extensions.rb
 - lib/brick/frameworks/cucumber.rb