brick 1.0.17 → 1.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f1a45a5262526e69cf49f16773049eb348e3971bddf09ecf05927002a265019
-  data.tar.gz: e9566a423a19ab55d44522b44e8b4abfcc39e92335b6093fe782c6344644bbbe
+  metadata.gz: 41b64e2d571540382ce5ecd497f1e1413fde20119d46f1b24e1fae5af428fb45
+  data.tar.gz: 1c26ccf7b8df54fd121546e8daeeb9508561328186af46aea8ba1bd819524532
 SHA512:
-  metadata.gz: cb89dff96dccc7051bc854fe523b03f818255d81e4f2e2a65eb9808115e719b8bad98e38114f15ee79b32b1f035c95c364a74392948cd2e99f4030e6988e0217
-  data.tar.gz: cd5507fde2f1f23481696ab051d14f89e5e7e7d3fc2be97af947ff287313b7ada8ca7b4e3f9e0e54dc2ab7f14e7f39a3c18f78cf7fc995c58b3d60cf68487973
+  metadata.gz: e103d061b74402f3fe0b944d06b30c20f053166c706a54f15753afc8cb0c703ae71f83bd88191f985a37180cb9bdafdba918178174df08f58f683a723fcfb73a
+  data.tar.gz: 13a7dce7f4f5789a0d7a0c6cae4adcaf2f44d22d0f59c355d75102a7f08292d80c781f8d33be121801d375fd33fed8bcdf4ef6b56108ef8f4ab4110c1f49e296

data/lib/brick/config.rb

@@ -108,7 +108,7 @@ module Brick
     end
 
     def exclude_tables
-      @mutex.synchronize { @exclude_tables }
+      @mutex.synchronize { @exclude_tables || [] }
     end
 
     def exclude_tables=(value)

data/lib/brick/extensions.rb

@@ -32,32 +32,101 @@
 
 # Currently quadrupling up routes
 
+
+# From the North app:
+# undefined method `built_in_role_path' when referencing show on a subclassed STI:
+#  http://localhost:3000/roles/3?_brick_schema=cust1
+
+
 # ==========================================================
 # Dynamically create model or controller classes when needed
 # ==========================================================
 
 # By default all models indicate that they are not views
+module Arel
+  class Table
+    def _arel_table_type
+      # AR < 4.2 doesn't have type_caster at all, so rely on an instance variable getting set
+      # AR 4.2 - 5.1 have buggy type_caster entries for the root node
+      instance_variable_get(:@_arel_table_type) ||
+      # 5.2-7.0 does type_caster just fine, no bugs there, but the property with the type differs:
+      # 5.2 has "types" as public, 6.0 "types" as private, and >= 6.1 "klass" as private.
+      ((tc = send(:type_caster)) && tc.instance_variable_get(:@types)) ||
+      tc.send(:klass)
+    end
+  end
+end
+
 module ActiveRecord
   class Base
+    def self._assoc_names
+      @_assoc_names ||= {}
+    end
+
     def self.is_view?
       false
     end
 
     # Used to show a little prettier name for an object
-    def brick_descrip
-      klass = self.class
-      # If available, parse simple DSL attached to a model in order to provide a friendlier name.
-      # Object property names can be referenced in square brackets like this:
-      # { 'User' => '[profile.firstname] [profile.lastname]' }
-
+    def self.brick_get_dsl
       # If there's no DSL yet specified, just try to find the first usable column on this model
-      unless ::Brick.config.model_descrips[klass.name]
-        descrip_col = (klass.columns.map(&:name) - klass._brick_get_fks -
+      unless (dsl = ::Brick.config.model_descrips[name])
+        descrip_col = (columns.map(&:name) - _brick_get_fks -
                       (::Brick.config.metadata_columns || []) -
-                      [klass.primary_key]).first
-        ::Brick.config.model_descrips[klass.name] = "[#{descrip_col}]" if descrip_col
+                      [primary_key]).first
+        dsl = ::Brick.config.model_descrips[name] = "[#{descrip_col}]" if descrip_col
       end
-      if (dsl ||= ::Brick.config.model_descrips[klass.name])
+      dsl
+    end
+
+    # Pass in true or a JoinArray
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {})
+      build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
+      build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+      members = []
+      bracket_name = nil
+      prefix = [prefix] unless prefix.is_a?(Array)
+      if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        klass = nil
+        dsl.each_char do |ch|
+          if bracket_name
+            if ch == ']' # Time to process a bracketed thing?
+              parts = bracket_name.split('.')
+              first_parts = parts[0..-2].map { |part| klass = klass.reflect_on_association(part_sym = part.to_sym).klass; part_sym }
+              parts = prefix + first_parts + [parts[-1]]
+              if parts.length > 1
+                s = build_array
+                parts[0..-3].each { |v| s = s[v.to_sym] }
+                s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
+                translations[parts[0..-2].join('.')] = klass
+              end
+              members << parts
+              bracket_name = nil
+            else
+              bracket_name << ch
+            end
+          elsif ch == '['
+            bracket_name = +''
+            klass = self
+          end
+        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
+      end
+      members
+    end
+
+    # If available, parse simple DSL attached to a model in order to provide a friendlier name.
+    # Object property names can be referenced in square brackets like this:
+    # { 'User' => '[profile.firstname] [profile.lastname]' }
+    def brick_descrip
+      self.class.brick_descrip(self)
+    end
+
+    def self.brick_descrip(obj, data = nil, pk_alias = nil)
+      if (dsl = ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
+        idx = -1
         caches = {}
         output = +''
         is_brackets_have_content = false
@@ -65,18 +134,23 @@ module ActiveRecord
         dsl.each_char do |ch|
           if bracket_name
             if ch == ']' # Time to process a bracketed thing?
-              obj_name = +''
-              obj = self
-              bracket_name.split('.').each do |part|
-                obj_name += ".#{part}"
-                obj = if caches.key?(obj_name)
-                        caches[obj_name]
+              datum = if data
+                        data[idx += 1].to_s
                       else
-                        (caches[obj_name] = obj&.send(part.to_sym))
+                        obj_name = +''
+                        this_obj = obj
+                        bracket_name.split('.').each do |part|
+                          obj_name += ".#{part}"
+                          this_obj = if caches.key?(obj_name)
+                                       caches[obj_name]
+                                     else
+                                       (caches[obj_name] = this_obj&.send(part.to_sym))
+                                     end
+                        end
+                        this_obj&.to_s || ''
                       end
-              end
-              is_brackets_have_content = true unless (obj&.to_s).blank?
-              output << (obj&.to_s || '')
+              is_brackets_have_content = true unless (datum).blank?
+              output << (datum || '')
               bracket_name = nil
             else
               bracket_name << ch
@@ -91,10 +165,14 @@ module ActiveRecord
       end
       if is_brackets_have_content
         output
-      elsif klass.primary_key
-        "#{klass.name} ##{send(klass.primary_key)}"
+      elsif pk_alias
+        if (id = obj.send(pk_alias))
+          "#{klass.name} ##{id}"
+        end
+      # elsif klass.primary_key
+      #   "#{klass.name} ##{obj.send(klass.primary_key)}"
       else
-        to_s
+        obj.to_s
       end
     end
 
@@ -106,9 +184,91 @@ module ActiveRecord
   end
 
   class Relation
-    def brick_where(params)
+    attr_reader :_brick_chains
+
+    # CLASS STUFF
+    def _recurse_arel(piece, prefix = '')
+      names = []
+      # Our JOINs mashup of nested arrays and hashes
+      # binding.pry if defined?(@arel)
+      case piece
+      when Array
+        names += piece.inject([]) { |s, v| s + _recurse_arel(v, prefix) }
+      when Hash
+        names += piece.inject([]) do |s, v|
+          new_prefix = "#{prefix}#{v.first}_"
+          s << [v.last.shift, new_prefix]
+          s + _recurse_arel(v.last, new_prefix)
+        end
+
+      # ActiveRecord AREL objects
+      when Arel::Nodes::Join # INNER or OUTER JOIN
+        # rubocop:disable Style/IdenticalConditionalBranches
+        if piece.right.is_a?(Arel::Table) # Came in from AR < 3.2?
+          # Arel 2.x and older is a little curious because these JOINs work "back to front".
+          # The left side here is either another earlier JOIN, or at the end of the whole tree, it is
+          # the first table.
+          names += _recurse_arel(piece.left)
+          # The right side here at the top is the very last table, and anywhere else down the tree it is
+          # the later "JOIN" table of this pair.  (The table that comes after all the rest of the JOINs
+          # from the left side.)
+          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)
+          # 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
+          end
+          (_brick_chains[table._arel_table_type] ||= []) << (alias_name || table.table_alias || table.name)
+          # puts "YES! #{self.object_id}"
+        end
+        # rubocop:enable Style/IdenticalConditionalBranches
+      when Arel::Table # Table
+        names << [piece._arel_table_type, (piece.table_alias || piece.name)]
+      when Arel::Nodes::TableAlias # Alias
+        # Can get the real table name from:  self._recurse_arel(piece.left)
+        names << [piece.left._arel_table_type, piece.right.to_s] # This is simply a string; the alias name itself
+      when Arel::Nodes::JoinSource # Leaving this until the end because AR < 3.2 doesn't know at all about JoinSource!
+        # Spin up an empty set of Brick alias name chains at the start
+        @_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)]
+        # The right side is an array of all JOINs
+        piece.right.each { |join| names << _recurse_arel(join) }
+      end
+      names
+    end
+
+    # INSTANCE STUFF
+    def _arel_alias_names
+      # %%% If with Rails 3.1 and older you get "NoMethodError: undefined method `eq' for nil:NilClass"
+      # when trying to call relation.arel, then somewhere along the line while navigating a has_many
+      # relationship it can't find the proper foreign key.
+      core = arel.ast.cores.first
+      # Accommodate AR < 3.2
+      if core.froms.is_a?(Arel::Table)
+        # All recent versions of AR have #source which brings up an Arel::Nodes::JoinSource
+        _recurse_arel(core.source)
+      else
+        # With AR < 3.2, "froms" brings up the top node, an Arel::Nodes::InnerJoin
+        _recurse_arel(core.froms)
+      end
+    end
+
+    def brick_select(params, selects = nil, bt_descrip = {}, hm_counts = {}, join_array = ::Brick::JoinArray.new
+      # , is_add_bts, is_add_hms
+    )
+      is_add_bts = is_add_hms = true
       wheres = {}
-      rel_joins = []
+      has_hm = false
       params.each do |k, v|
         case (ks = k.split('.')).length
         when 1
@@ -116,28 +276,90 @@ module ActiveRecord
         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&.columns&.map(&:name)&.include?(ks.last)
-
-          rel_joins << assoc_name unless rel_joins.include?(assoc_name)
+          next unless (assoc = klass.reflect_on_association(assoc_name))&.klass&.columns&.map(&:name)&.include?(ks.last)
+
+          # So that we can map an association name to any special alias name used in an AREL query
+          ans = (assoc.klass._assoc_names[assoc_name] ||= [])
+          ans << assoc.klass unless ans.include?(assoc.klass)
+          # There is some potential for duplicates when there is an HM-based where in play.  De-duplicate if so.
+          has_hm ||= assoc.macro == :has_many
+          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
         end
         wheres[k] = v.split(',')
       end
-      unless wheres.empty?
-        where!(wheres)
-        joins!(rel_joins) unless rel_joins.empty?
-        wheres # Return the specific parameters that we did use
+      # distinct! if has_hm
+
+      # %%% Skip the metadata columns
+      if selects&.empty? # Default to all columns
+        columns.each do |col|
+          selects << "#{table.name}.#{col.name}"
+        end
+      end
+
+      # Search for BT, HM, and HMT DSL stuff
+      translations = {}
+      if is_add_bts || is_add_hms
+        bts, hms, associatives = ::Brick.get_bts_and_hms(klass)
+        bts.each do |_k, bt|
+          # join_array[bt.first] = nil # Store this relation name in our special collection for .joins()
+          bt_descrip[bt.first] = [bt.last, bt.last.brick_parse_dsl(join_array, bt.first, translations)]
+        end
+        hms.each do |k, hm|
+          join_array[k] = nil # Store this relation name in our special collection for .joins()
+          hm_counts[k] = nil # Placeholder that will be filled in once we know the proper table alias
+        end
+      end
+      where!(wheres) unless wheres.empty?
+      if join_array.present?
+        left_outer_joins!(join_array) # 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
+        groups = []
+        chains = rel_dupe._brick_chains
+        id_for_tables = {}
+        bt_columns = bt_descrip.each_with_object([]) do |v, s|
+          tbl_name = chains[v.last.first].first
+          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(tbl_name)
+            groups << (unaliased = "#{tbl_name}.#{id_col}")
+            selects << "#{unaliased} AS \"#{(id_alias = id_for_tables[tbl_name] = "_brfk_#{v.first}__#{id_col}")}\""
+            v.last << id_alias
+          end
+          if (col_name = v.last[1].last&.last)
+            v.last[1].map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
+              groups << (unaliased = "#{tbl_name = chains[sel_col.first].first}.#{sel_col.last}")
+              # col_name is weak when there are multiple, using sel_col.last instead
+              tbl_name2 = tbl_name.start_with?('public.') ? tbl_name[7..-1] : tbl_name
+              selects << "#{unaliased} AS \"#{(col_alias = "_brfk_#{tbl_name2}__#{sel_col.last}")}\""
+              v.last[1][idx] << col_alias
+            end
+          end
+        end
+        group!(core_selects + groups) if hm_counts.any? #  + bt_columns
+        join_array.each do |assoc_name|
+          # %%% Need to support {user: :profile}
+          next unless assoc_name.is_a?(Symbol)
+
+          klass = reflect_on_association(assoc_name)&.klass
+          table_alias = chains[klass].length > 1 ? chains[klass].shift : chains[klass].first
+          _assoc_names[assoc_name] = [table_alias, klass]
+        end
+        # Copy entries over
+        hm_counts.keys.each do |k|
+          hm_counts[k] = _assoc_names[k]
+        end
       end
+      wheres unless wheres.empty? # Return the specific parameters that we did use
     end
   end
 
   module Inheritance
     module ClassMethods
-      private
+    private
 
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
         if ::Brick.sti_models.key?(type_name)
-          # puts ['X', self.name, type_name].inspect
           _brick_find_sti_class(type_name)
         else
           # This auto-STI is more of a brute-force approach, building modules where needed
@@ -146,10 +368,8 @@ module ActiveRecord
           module_prefixes = type_name.split('::')
           module_prefixes.unshift('') unless module_prefixes.first.blank?
           module_name = module_prefixes[0..-2].join('::')
-          if ::Brick.config.sti_namespace_prefixes&.key?("::#{module_name}::") ||
-             ::Brick.config.sti_namespace_prefixes&.key?("#{module_name}::")
-            _brick_find_sti_class(type_name)
-          elsif File.exists?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
+          if (snp = ::Brick.config.sti_namespace_prefixes)&.key?("::#{module_name}::") || snp&.key?("#{module_name}::") ||
+             File.exist?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
             _brick_find_sti_class(type_name) # Find this STI class normally
           else
             # Build missing prefix modules if they don't yet exist
@@ -228,10 +448,9 @@ class Object
       end
 
       relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
-      is_controllers_enabled = ::Brick.enable_controllers? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
-      result = if is_controllers_enabled && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
+      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 = ActiveSupport::Inflector.singularize(plural_class_name).constantize)
+                 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
@@ -243,10 +462,10 @@ class Object
  
                  # Adjust for STI if we know of a base model for the requested model name
                  table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
-                               base_model.table_name
-                             else
-                               ActiveSupport::Inflector.pluralize(singular_table_name)
-                             end
+                                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) })
@@ -282,6 +501,7 @@ class Object
         end
         return
       end
+
       if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
         is_sti = true
       else
@@ -443,18 +663,27 @@ class Object
 
         code << "  def index\n"
         code << "    @#{table_name} = #{model.name}#{model.primary_key ? ".order(#{model.primary_key.inspect})" : '.all'}\n"
-        code << "    @#{table_name}.brick_where(params)\n"
+        code << "    @#{table_name}.brick_select(params)\n"
         code << "  end\n"
         self.define_method :index do
           ::Brick.set_db_schema(params)
-          ar_relation = model.primary_key ? model.order(model.primary_key) : model.all
-          instance_variable_set(:@_brick_params, ar_relation.brick_where(params))
-          instance_variable_set("@#{table_name}".to_sym, ar_relation)
+          ar_relation = model.all # model.primary_key ? model.order(model.primary_key) : model.all
+          @_brick_params = ar_relation.brick_select(params, (selects = []), (bt_descrip = {}), (hm_counts = {}), (join_array = ::Brick::JoinArray.new))
+          # %%% Add custom HM count columns
+          # %%% What happens when the PK is composite?
+          counts = hm_counts.each_with_object([]) { |v, s| s << "COUNT(DISTINCT #{v.last.first}.#{v.last.last.primary_key}) AS _br_#{v.first}_ct" }
+          puts counts.inspect
+          # *selects, 
+          instance_variable_set("@#{table_name}".to_sym, ar_relation.dup._select!(*selects, *counts))
+          # binding.pry
+          @_brick_bt_descrip = bt_descrip
+          @_brick_hm_counts = hm_counts
+          @_brick_join_array = join_array
         end
 
         if model.primary_key
           code << "  def show\n"
-          code << "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n"
+          code << (find_by_id = "    @#{singular_table_name} = #{model.name}.find(params[:id].split(','))\n")
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
@@ -463,9 +692,36 @@ class Object
         end
 
         # By default, views get marked as read-only
-        unless (relation = relations[model.table_name]).key?(:isView)
-          code << "  # (Define :new, :create, :edit, :update, and :destroy)\n"
-          # Get column names for params from relations[model.table_name][:cols].keys
+        unless false # model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          code << "  # (Define :new, :create)\n"
+
+          if model.primary_key
+            is_need_params = true
+            # code << "  # (Define :edit, and :destroy)\n"
+            code << "  def update\n"
+            code << find_by_id
+            params_name = "#{singular_table_name}_params"
+            code << "    @#{singular_table_name}.update(#{params_name})\n"
+            code << "  end\n"
+            self.define_method :update do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(params[:id].split(','))))
+              obj = obj.first if obj.is_a?(Array)
+              obj.send(:update, send(params_name = params_name.to_sym))
+            end
+          end
+
+          if is_need_params
+            code << "private\n"
+            code << "  def params\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
+              params.require(singular_table_name.to_sym).permit(model.columns_hash.keys)
+            end
+            private params_name
+            # Get column names for params from relations[model.table_name][:cols].keys
+          end
         end
         code << "end # #{class_name}\n\n"
       end # class definition
@@ -495,9 +751,9 @@ module ActiveRecord::ConnectionHandling
   end
 
   def _brick_reflect_tables
-      if (relations = ::Brick.relations).empty?
-      # Only for Postgres?  (Doesn't work in sqlite3)
-      # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
+    if (relations = ::Brick.relations).empty?
+    # Only for Postgres?  (Doesn't work in sqlite3)
+    # puts ActiveRecord::Base.connection.execute("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
     schema_sql = 'SELECT NULL AS table_schema;'
     case ActiveRecord::Base.connection.adapter_name
@@ -587,6 +843,25 @@ module ActiveRecord::ConnectionHandling
         end
       end
 
+      # # Add unique OIDs
+      # if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      #   ActiveRecord::Base.execute_sql(
+      #     "SELECT c.oid, n.nspname, c.relname
+      #     FROM pg_catalog.pg_namespace AS n
+      #       INNER JOIN pg_catalog.pg_class AS c ON n.oid = c.relnamespace
+      #     WHERE c.relkind IN ('r', 'v')"
+      #   ).each do |r|
+      #     next if ['pg_catalog', 'information_schema', ''].include?(r['nspname']) ||
+      #       ['ar_internal_metadata', 'schema_migrations'].include?(r['relname'])
+      #     relation = relations.fetch(r['relname'], nil)
+      #     if relation
+      #       (relation[:oid] ||= {})[r['nspname']] = r['oid']
+      #     else
+      #       puts "Where is #{r['nspname']} #{r['relname']} ?"
+      #     end
+      #   end
+      # end
+
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL', 'Mysql2'
         sql = ActiveRecord::Base.send(:sanitize_sql_array, [
@@ -629,14 +904,12 @@ module ActiveRecord::ConnectionHandling
       puts "\nClasses that can be built from views:"
       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
-
-    # relations.keys.each { |k| ActiveSupport::Inflector.singularize(k).camelize.constantize }
-    # Layout table describes permissioned hierarchy throughout
   end
 end
 
@@ -681,7 +954,7 @@ module Brick
         missing << fk[0] unless relations.key?(fk[0])
         missing << primary_table unless is_class || relations.key?(primary_table)
         unless missing.empty?
-          tables = relations.reject { |k, v| v.fetch(:isView, nil) }.keys.sort
+          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
@@ -690,7 +963,7 @@ module Brick
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} 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[0] && v[:fk] == fk[1] && 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
@@ -712,19 +985,19 @@ module Brick
         # assoc_bt[:inverse_of] = primary_class.reflect_on_all_associations.find { |a| a.foreign_key == bt[1] }
       end
 
-      unless is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
-        cnstr_name = "hm_#{cnstr_name}"
-        if (assoc_hm = hms.fetch(cnstr_name, nil))
-          assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
-          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[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
-          hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
-          hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
-        end
-        assoc_bt[:inverse] = assoc_hm
+      return if is_class || ::Brick.config.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[2] }
+
+      cnstr_name = "hm_#{cnstr_name}"
+      if (assoc_hm = hms.fetch(cnstr_name, nil))
+        assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
+        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[cnstr_name] = { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0], inverse: assoc_bt }
+        hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
+        hm_counts[fk[0]] = hm_counts.fetch(fk[0]) { 0 } + 1
       end
+      assoc_bt[:inverse] = assoc_hm
       # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
     end
   end