brick 1.0.19 → 1.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57a1d4e3774c90984cfc435d9ed87e42b74c364b01fd7ced7df740f5005b935e
-  data.tar.gz: 8222088ef88ca48cd90144c8503638644195f2d593ff95d7b2e3530304ac6fb2
+  metadata.gz: 82ebef3561b9cd7b8abcbbd8a30b7687485543ddf1a0900a9935dfb99299f13f
+  data.tar.gz: ba071d53409fd8d4833693907364c745585aeb0bb18e885fcf7cbf1bd23b9940
 SHA512:
-  metadata.gz: 2b785c34e1a21563232ae54f6af25989fe02b73f92eb1327b27d6f21e80b7e353a5995305c4c1188dda885465a196f87fb5979a13c3e6a0219d4895dc59593dd
-  data.tar.gz: bd2018d48dad15f51d7a87e39d2710bde9a5becbe969e741004bf730f57faecbd84a81a2f75cfdd60c2ff48f239fe6c5c8d3f47b4b2f79e355b7f100f9bb7943
+  metadata.gz: 69ad3ae158a8e478864db65dc808152d4b1b16bdc8779b1a651f59f199167daf00d2aa10018c5f65d5e619bbca4c09e99bc319ca736eed57023d61e6067ea365
+  data.tar.gz: 18ca63e176e12ea50a5168e835a2eddfa66c8f522943d42e6d895d2f3e05d0cf6d396ab28d79f98898c91670b618cc27dbad5fa0bc9129a3edcfc3f74f5db029

data/lib/brick/config.rb

@@ -74,6 +74,20 @@ module Brick
       @mutex.synchronize { @exclude_hms = skips }
     end
 
+    # Skip showing counts for these specific has_many associations when building auto-generated #index views
+    def skip_index_hms
+      @mutex.synchronize { @skip_index_hms || {} }
+    end
+
+    def skip_index_hms=(skips)
+      @mutex.synchronize do
+        @skip_index_hms ||= skips.each_with_object({}) do |v, s|
+                              class_name, assoc_name = v.split('.')
+                              (s[class_name] ||= {})[assoc_name.to_sym] = nil
+                            end
+      end
+    end
+
     # Associations to treat as a has_one
     def has_ones
       @mutex.synchronize { @has_ones }

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
+      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
-      if (dsl ||= ::Brick.config.model_descrips[klass.name])
+      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,13 +165,25 @@ module ActiveRecord
       end
       if is_brackets_have_content
         output
-      elsif klass.primary_key
-        "#{klass.name} ##{send(klass.primary_key)}"
+      elsif pk_alias
+        if (id = pk_alias.map { |pk_alias_part| obj.send(pk_alias_part) })
+          "#{klass.name} ##{id.join(', ')}"
+        end
+      # elsif klass.primary_key
+      #   "#{klass.name} ##{obj.send(klass.primary_key)}"
       else
-        to_s
+        obj.to_s
       end
     end
 
+    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)
+      link = Class.new.extend(ActionView::Helpers::UrlHelper).link_to(name, model_path)
+      model_underscore == assoc_name ? link : "#{assoc_name}-#{link}".html_safe
+    end
+
   private
 
     def self._brick_get_fks
@@ -106,9 +192,114 @@ 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
+
+      # %%% 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 will receive this relation name when calling #brick_parse_dsl
+          bt_descrip[bt.first] = [bt.last, bt.last.brick_parse_dsl(join_array, bt.first, translations)]
+        end
+        skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
+        hms.each do |k, hm|
+          next if skip_klass_hms.key?(k)
+
+          hm_counts[k] = hm
+        end
+      end
+
       wheres = {}
-      rel_joins = []
       params.each do |k, v|
         case (ks = k.split('.')).length
         when 1
@@ -116,23 +307,87 @@ 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)
+          next unless klass.reflect_on_association(assoc_name)&.klass&.columns&.any? { |col| col.name == ks.last }
 
-          rel_joins << assoc_name unless rel_joins.include?(assoc_name)
+          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
+
+      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
+        chains = rel_dupe._brick_chains
+        id_for_tables = Hash.new { |h, k| h[k] = [] }
+        field_tbl_names = Hash.new { |h, k| h[k] = {} }
+        bt_columns = bt_descrip.each_with_object([]) do |v, s|
+          tbl_name = field_tbl_names[v.first][v.last.first] ||= shift_or_first(chains[v.last.first])
+          if (id_col = v.last.first.primary_key) && !id_for_tables.key?(v.first) # was tbl_name
+            # Accommodate composite primary key by allowing id_col to come in as an array
+            (id_col.is_a?(Array) ? id_col : [id_col]).each do |id_part|
+              selects << "#{"#{tbl_name}.#{id_part}"} AS \"#{(id_alias = "_brfk_#{v.first}__#{id_part}")}\""
+              id_for_tables[v.first] << id_alias
+            end
+            v.last << id_for_tables[v.first]
+          end
+          if (col_name = v.last[1].last&.last)
+            field_tbl_name = nil
+            v.last[1].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])
+              # col_name is weak when there are multiple, using sel_col.last instead
+              selects << "#{"#{field_tbl_name}.#{sel_col.last}"} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
+              v.last[1][idx] << col_alias
+            end
+          end
+        end
+        join_array.each do |assoc_name|
+          # %%% Need to support {user: :profile}
+          next unless assoc_name.is_a?(Symbol)
+
+          table_alias = shift_or_first(chains[klass = reflect_on_association(assoc_name)&.klass])
+          _assoc_names[assoc_name] = [table_alias, klass]
+        end
+      end
+      # Add derived table JOIN for the has_many counts
+      hm_counts.each do |k, hm|
+        associative = nil
+        count_column = if hm.options[:through]
+                          fk_col = (associative = associatives[hm.name]).foreign_key
+                          hm.foreign_key
+                        else
+                          fk_col = hm.foreign_key
+                          hm.klass.primary_key || '*'
+                        end
+        tbl_alias = "_br_#{hm.name}"
+        pri_tbl = hm.active_record
+        if fk_col.is_a?(Array) # Composite key?
+          on_clause = []
+          fk_col.each_with_index { |fk_col_part, idx| on_clause << "#{tbl_alias}.#{fk_col_part} = #{pri_tbl.table_name}.#{pri_tbl.primary_key[idx]}" }
+          joins!("LEFT OUTER
+JOIN (SELECT #{fk_col.join(', ')}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.name || hm.klass.table_name} GROUP BY #{(1..fk_col.length).to_a.join(', ')}) AS #{tbl_alias}
+  ON #{on_clause.join(' AND ')}")
+        else
+          joins!("LEFT OUTER
+JOIN (SELECT #{fk_col}, COUNT(#{count_column}) AS _ct_ FROM #{associative&.name || hm.klass.table_name} GROUP BY 1) AS #{tbl_alias}
+  ON #{tbl_alias}.#{fk_col} = #{pri_tbl.table_name}.#{pri_tbl.primary_key}")
+        end
       end
+      where!(wheres) unless wheres.empty?
+      wheres unless wheres.empty? # Return the specific parameters that we did use
+    end
+
+  private
+
+    def shift_or_first(ary)
+      ary.length > 1 ? ary.shift : ary.first
     end
   end
 
   module Inheritance
     module ClassMethods
-      private
+    private
 
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
@@ -145,10 +400,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.exist?(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
@@ -227,10 +480,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
@@ -281,6 +533,7 @@ class Object
         end
         return
       end
+
       if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
         is_sti = true
       else
@@ -328,27 +581,30 @@ class Object
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
           hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
             # The key in each hash entry (fk.first) is the constraint name
-            assoc_name = (assoc = fk.last)[:assoc_name]
-            inverse_assoc_name = assoc[:inverse]&.fetch(:assoc_name, nil)
+            inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
             options = {}
             singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
             macro = if assoc[:is_bt]
                       # Try to take care of screwy names if this is a belongs_to going to an STI subclass
-                      if (primary_class = assoc.fetch(:primary_class, nil)) &&
-                         (sti_inverse_assoc = primary_class.reflect_on_all_associations.find { |a| a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key })
-                        assoc_name = sti_inverse_assoc.options[:inverse_of].to_s || assoc_name
-                      end
+                      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
+                                      end
+                                     sti_inverse_assoc.options[:inverse_of]&.to_s || assoc_name
+                                   else
+                                     assoc[:assoc_name]
+                                   end
                       need_class_name = singular_table_name.underscore != assoc_name
                       need_fk = "#{assoc_name}_id" != assoc[:fk]
                       if (inverse = assoc[:inverse])
                         inverse_assoc_name, _x = _brick_get_hm_assoc_name(relations[assoc[:inverse_table]], inverse)
                         if (has_ones = ::Brick.config.has_ones&.fetch(inverse[:alternate_name].camelize, nil))&.key?(singular_inv_assoc_name = ActiveSupport::Inflector.singularize(inverse_assoc_name))
                           inverse_assoc_name = if has_ones[singular_inv_assoc_name]
-                                                need_inverse_of = true
-                                                has_ones[singular_inv_assoc_name]
-                                              else
-                                                singular_inv_assoc_name
-                                              end
+                                                 need_inverse_of = true
+                                                 has_ones[singular_inv_assoc_name]
+                                               else
+                                                 singular_inv_assoc_name
+                                               end
                         end
                       end
                       :belongs_to
@@ -359,12 +615,12 @@ class Object
                       need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table])}_id" != assoc[:fk]
                       # 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))
-                        assoc_name = if has_ones[singular_assoc_name]
-                                      need_class_name = true
-                                      has_ones[singular_assoc_name]
-                                    else
-                                      singular_assoc_name
-                                    end
+                        assoc_name = if (custom_assoc_name = has_ones[singular_assoc_name])
+                                       need_class_name = custom_assoc_name != singular_assoc_name
+                                       custom_assoc_name
+                                     else
+                                       singular_assoc_name
+                                     end
                         :has_one
                       else
                         :has_many
@@ -442,13 +698,21 @@ 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 << "_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
+          @_brick_bt_descrip = bt_descrip
+          @_brick_hm_counts = hm_counts
+          @_brick_join_array = join_array
         end
 
         if model.primary_key
@@ -500,7 +764,8 @@ class Object
 
     def _brick_get_hm_assoc_name(relation, hm_assoc)
       if relation[:hm_counts][hm_assoc[:assoc_name]]&.> 1
-        [ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name]), true]
+        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]
       end
@@ -757,18 +1022,16 @@ module Brick
 
       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))
+      if (assoc_hm = hms.fetch((hm_cnstr_name = "hm_#{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 }
+        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 }
         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
 end