brick 1.0.18 → 1.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: add7e232024e140e2fb089ef158600e2a2a955efd787dc986769b43b4b1f6d24
-  data.tar.gz: a45d187a7b739f90b1fede46dfc9f63a2057a3410d052e0ad57322f4741ebfee
+  metadata.gz: 0ad289d9f4db9ef6ce9edcfb8948926d4a61910294291272ccf2b342fa2f5051
+  data.tar.gz: 9030f9ccf39d7f0a9a0ff9413e4f24ee7a46beaf3aba056e9875fc5c29551419
 SHA512:
-  metadata.gz: '0897e041c617f0e1e695d0402784184ce2f7ec575d9b0e7a7b1b59b2efbcb40a4de28bcbe2eb124f576dddb8e7371f572c67ee3b19120cd281bf3358249b4508'
-  data.tar.gz: fc7a4a93a7d2409f4aa82fb3dbf23710aaad45a1dca1193c8cbcefa86d5d9061a773214c8fe0dd02375660bfb6e5a9856df3a202f57a73990e79d23850918f9b
+  metadata.gz: ed6f08eabba91cb304141a0c84884cfbeaae0087094b1fe1ff4a80195aee44dbb697c385ab9d7afaac2e337f9008bc7bef059be98f95264fec34a2288beaff6b
+  data.tar.gz: 5ebbb793d23634232a529b3d39224e1e4deaa010cf8bf2841effe20a9e3b4d7079fb7163e6c2f90feeed8526c4a1314f319bad47d1c8a6079bf54ca92f0e6224

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,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,93 @@ 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
+        skip_klass_hms = ::Brick.config.skip_index_hms[klass.name] || {}
+        hms.each do |k, hm|
+          next if skip_klass_hms.key?(k)
+
+          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 +371,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 +451,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 +465,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 +504,7 @@ class Object
         end
         return
       end
+
       if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
         is_sti = true
       else
@@ -443,13 +666,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 << "COUNT(DISTINCT #{v.last.first}.#{v.last.last.primary_key}) 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
@@ -522,9 +753,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
@@ -614,6 +845,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, [
@@ -706,7 +956,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
@@ -715,7 +965,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
@@ -737,19 +987,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

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

@@ -7,10 +7,12 @@ module Brick
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
       config.brick = ActiveSupport::OrderedOptions.new
       ActiveSupport.on_load(:before_initialize) do |app|
+        is_development = (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
         ::Brick.enable_models = app.config.brick.fetch(:enable_models, true)
-        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, false)
-        ::Brick.enable_views = app.config.brick.fetch(:enable_views, false)
-        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, false)
+        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, is_development)
+        require 'brick/join_array' if ::Brick.enable_controllers?
+        ::Brick.enable_views = app.config.brick.fetch(:enable_views, is_development)
+        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, is_development)
         ::Brick.skip_database_views = app.config.brick.fetch(:skip_database_views, false)
 
         # Specific database tables and views to omit when auto-creating models
@@ -43,7 +45,7 @@ module Brick
         # ====================================
         # Dynamically create generic templates
         # ====================================
-        if ::Brick.enable_views? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
+        if ::Brick.enable_views?
           ActionView::LookupContext.class_exec do
             alias :_brick_template_exists? :template_exists?
             def template_exists?(*args, **options)
@@ -51,14 +53,12 @@ module Brick
                 # Need to return true if we can fill in the blanks for a missing one
                 # args will be something like:  ["index", ["categories"]]
                 model = args[1].map(&:camelize).join('::').singularize.constantize
-                if (
-                      is_template_exists = model && (
-                        ['index', 'show'].include?(args.first) || # Everything has index and show
-                        # Only CRU stuff has create / update / destroy
-                        (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
-                      )
-                    )
-                  instance_variable_set(:@_brick_model, model)
+                if is_template_exists = model && (
+                     ['index', 'show'].include?(args.first) || # Everything has index and show
+                     # Only CUD stuff has create / update / destroy
+                      (!model.is_view? && ['new', 'create', 'edit', 'update', 'destroy'].include?(args.first))
+                   )
+                  @_brick_model = model
                 end
               end
               is_template_exists
@@ -66,56 +66,50 @@ module Brick
 
             alias :_brick_find_template :find_template
             def find_template(*args, **options)
-              if @_brick_model
-                model_name = @_brick_model.name
-                pk = @_brick_model.primary_key
-                obj_name = model_name.underscore
-                table_name = model_name.pluralize.underscore
-                # This gets has_many as well as has_many :through
-                # %%% weed out ones that don't have an available model to reference
-                bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
-                # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
-                # as well as any possible polymorphic associations
-                exclude_hms = {}
-                associatives = hms.each_with_object({}) do |hmt, s|
-                  if (through = hmt.last.options[:through])
-                    exclude_hms[through] = nil
-                    s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
-                  elsif hmt.last.inverse_of.nil?
-                    puts "SKIPPING #{hmt.last.name.inspect}"
-                    # %%% If we don't do this then below associative.name will find that associative is nil
-                    exclude_hms[hmt.last.name] = nil
-                  end
-                end
+              return  _brick_find_template(*args, **options) unless @_brick_model
+
+              model_name = @_brick_model.name
+              pk = @_brick_model.primary_key
+              obj_name = model_name.underscore
+              table_name = model_name.pluralize.underscore
+              bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
+              hms_columns = +'' # Used for 'index'
+              skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
+              hms_headers = hms.each_with_object([]) do |hm, s|
+                hm_assoc = hm.last
+                if args.first == 'index'
+                  hm_fk_name = if hm_assoc.options[:through]
+                                 associative = associatives[hm_assoc.name]
+                                 "'#{associative.name}.#{associative.foreign_key}'"
+                               else
+                                 hm_assoc.foreign_key
+                               end
+                  hms_columns << if hm_assoc.macro == :has_many
+                    set_ct = if skip_klass_hms.key?((assoc_name = hm.first).to_sym)
+                               'nil'
+                             else
+                               "#{obj_name}._br_#{assoc_name}_ct"
+                             end
 
-                schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
-                table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
-                                .each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
-                hms_columns = +'' # Used for 'index'
-                hms_headers = hms.each_with_object([]) do |hm, s|
-                  next if exclude_hms.key?((hm_assoc = hm.last).name)
-
-                  if args.first == 'index'
-                    hm_fk_name = if hm_assoc.options[:through]
-                                   associative = associatives[hm_assoc.name]
-                                   "'#{associative.name}.#{associative.foreign_key}'"
-                                 else
-                                   hm_assoc.foreign_key
-                                 end
-                    hms_columns << if hm_assoc.macro == :has_many
 "<td>
-  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
+  <%= ct = #{set_ct}
+      link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless ct&.zero? %>
 </td>\n"
-                                   else # has_one
+                                 else # has_one
 "<td>
   <%= obj = #{obj_name}.#{hm.first}; link_to(obj.brick_descrip, obj) if obj %>
 </td>\n"
-                                   end
-                  end
-                  s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
+                                 end
                 end
+                s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
+              end
 
-                css = "<style>
+              schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
+              # %%% If we are not auto-creating controllers (or routes) then omit by default, and if enabled anyway, such as in a development
+              # environment or whatever, then get either the controllers or routes list instead
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables)
+                              .each_with_object(+'') { |v, s| s << "<option value=\"#{v.underscore.pluralize}\">#{v}</option>" }.html_safe
+              css = +"<style>
 table {
   border-collapse: collapse;
   margin: 25px 0;
@@ -189,7 +183,12 @@ def hide_bcrypt(val)
   is_bcrypt?(val) ? '(hidden)' : val
 end %>"
 
-                script = "<script>
+              if ['index', 'show', 'update'].include?(args.first)
+                css << "<% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} } %>"
+              end
+
+              # %%% When doing schema select, if there's an ID then remove it, or if we're on a new page go to index
+              script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
 var brickSchema;
 if (schemaSelect) {
@@ -243,9 +242,8 @@ function changeout(href, param, value) {
   return hrefParts[0] + \"?\" + Object.keys(params).reduce(function (s, v) { s.push(v + \"=\" + params[v]); return s; }, []).join(\"&\");
 }
 </script>"
-
-                inline = case args.first
-                when 'index'
+              inline = case args.first
+                       when 'index'
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
@@ -253,9 +251,8 @@ function changeout(href, param, value) {
 <h1>#{model_name.pluralize}</h1>
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
 <table id=\"#{table_name}\">
-  <thead><tr>#{"<th></th>" if pk }
-  <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
-     @#{table_name}.columns.map(&:name).each do |col| %>
+  <thead><tr>#{'<th></th>' if pk}
+  <% @#{table_name}.columns.map(&:name).each do |col| %>
     <% next if col == '#{pk}' || ::Brick.config.metadata_columns.include?(col) %>
     <th>
     <% if (bt = bts[col]) %>
@@ -271,16 +268,16 @@ function changeout(href, param, value) {
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk }
+    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk}
     <% #{obj_name}.attributes.each do |k, val| %>
-      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
+      <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) || k.start_with?('_brfk_') || (k.start_with?('_br_') && k.end_with?('_ct')) %>
       <td>
       <% if (bt = bts[k]) %>
-        <%# Instead of just 'bt_obj we have to put in all of this junk:
-        # send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))
-        # Otherwise we get stuff like:
-        # ActionView::Template::Error (undefined method `vehicle_path' for #<ActionView::Base:0x0000000033a888>) %>
-        <%= bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
+        <%# binding.pry if bt.first == :user %>
+        <% bt_txt = bt[1].brick_descrip(#{obj_name}, @_brick_bt_descrip[bt.first][1].map { |z| #{obj_name}.send(z.last) }, @_brick_bt_descrip[bt.first][2]) %>
+        <% bt_id_col = @_brick_bt_descrip[bt.first][2]; bt_id = #{obj_name}.send(bt_id_col) if bt_id_col %>
+        <%= bt_id ? link_to(bt_txt, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_id)) : bt_txt %>
+        <%#= Previously was:  bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_path_base = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
       <% else %>
         <%= hide_bcrypt(val) %>
       <% end %>
@@ -295,7 +292,7 @@ function changeout(href, param, value) {
 
 #{"<hr><%= link_to \"New #{obj_name}\", new_#{obj_name}_path %>" unless @_brick_model.is_view?}
 #{script}"
-                when 'show', 'update'
+                       when 'show', 'update'
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
@@ -308,8 +305,7 @@ function changeout(href, param, value) {
    # url = send(:#{model_name.underscore}_path, obj.#{pk})
    form_for(obj) do |f| %>
   <table>
-  <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
-      @#{obj_name}.first.attributes.each do |k, val| %>
+  <% @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
     <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
@@ -331,7 +327,7 @@ function changeout(href, param, value) {
       html_options = { prompt: \"Select #\{bt_name\}\" }
       html_options[:class] = 'dimmed' unless val %>
       <%= f.select k.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options %>
-      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_class = bt_name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_path_base = bt_name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
     <% else case #{model_name}.column_for_attribute(k).type
       when :string, :text %>
         <% if is_bcrypt?(val) # || .readonly? %>
@@ -341,8 +337,13 @@ function changeout(href, param, value) {
         <% end %>
       <% when :boolean %>
         <%= f.check_box k.to_sym %>
-      <% when :integer, :date, :datetime, :decimal %>
+      <% when :integer, :decimal, :float, :date, :datetime, :time, :timestamp
+         # What happens when keys are UUID?
+         # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
+         # If it's not yet enabled then:  enable_extension 'uuid-ossp'
+         # ActiveUUID gem created a new :uuid type %>
         <%= val %>
+      <% when :binary, :primary_key %>
       <% end %>
     <% end %>
     </td>
@@ -354,6 +355,7 @@ function changeout(href, param, value) {
 
   #{hms_headers.map do |hm|
     next unless (pk = hm.first.klass.primary_key)
+
   "<table id=\"#{hm_name = hm.first.name.to_s}\">
     <tr><th>#{hm.last}</th></tr>
     <% collection = @#{obj_name}.first.#{hm_name}
@@ -369,19 +371,16 @@ function changeout(href, param, value) {
 <% end %>
 #{script}"
 
-                end
-                # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
-                keys = options.has_key?(:locals) ? options[:locals].keys : []
-                handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')
-                ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
-              else
-                _brick_find_template(*args, **options)
-              end
+                       end
+              # As if it were an inline template (see #determine_template in actionview-5.2.6.2/lib/action_view/renderer/template_renderer.rb)
+              keys = options.has_key?(:locals) ? options[:locals].keys : []
+              handler = ActionView::Template.handler_for_extension(options[:type] || 'erb')
+              ActionView::Template.new(inline, "auto-generated #{args.first} template", handler, locals: keys)
             end
           end
         end
 
-        if ::Brick.enable_routes? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
+        if ::Brick.enable_routes?
           ActionDispatch::Routing::RouteSet.class_exec do
             # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
             prepend ::Brick::RouteSet
@@ -391,17 +390,6 @@ 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).
         ::Brick.load_additional_references
-
-        # Find associative tables that can be set up for has_many :through
-        ::Brick.relations.each do |_key, tbl|
-          tbl_cols = tbl[:cols].keys
-          fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
-          # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
-          # foreign keys then it can act as an associative table and thus be used with has_many :through.
-          if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?
-            fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
-          end
-        end
       end
     end
   end

data/lib/brick/join_array.rb

@@ -0,0 +1,227 @@
+module Brick
+  # JoinArray and JoinHash
+  #
+  # These JOIN-related collection classes -- JoinArray and its related "partner in crime" JoinHash -- both interact to
+  # more easily build out nested sets of hashes and arrays to be used with ActiveRecord's .joins() method.  For example,
+  # if there is an Order, Customer, and Employee model, and Order belongs_to :customer and :employee, then from the
+  # perspective of Order all these three could be JOINed together by referencing the two belongs_to association names:
+  #
+  #  Order.joins([:customer, :employee])
+  #
+  # and from the perspective of Employee it would instead use a hash like this, using the has_many :orders association
+  # and the :customer belongs_to:
+  #
+  #  Employee.joins({ orders: :customer })
+  #
+  # (in both cases the same three tables are being JOINed, the two approaches differ just based on their starting standpoint.)
+  # These utility classes are designed to make building out any goofy linkages like this pretty simple in a few ways:
+  # ** if the same association is requested more than once then no duplicates.
+  # ** If a bunch of intermediary associations are referenced leading up to a final one then all of them get automatically built
+  #    out and added along the way, without any having to previously exist.
+  # ** If one reference was made previously and now another neighbouring one is called for, then what used to be a simple symbol
+  #    is automatically graduated into an array so that both members can be held.  For instance, if with the Order example above
+  #    there was also a LineItem model that belongs_to Order, then let's say you start from LineItem and want to now get all 4
+  #    related models.  You could start by going through :order to :employee like this:
+  #
+  # line_item_joins = JoinArray.new
+  # line_item_joins[:order] = :employee
+  # => { order: :employee }
+  #
+  #    and then add in the reference to :customer like this:
+  #
+  # line_item_joins[:order] = :customer
+  # => { order: [:employee, :customer] }
+  #
+  #    and then carry on incrementally building out more JOINs in whatever sequence makes the best sense.  This bundle of nested
+  #    stuff can then be used to query ActiveRecord like this:
+  #
+  # LineItem.joins(line_item_joins)
+
+  class JoinArray < Array
+    attr_reader :parent, :orig_parent, :parent_key
+    alias _brick_set []=
+
+    def [](*args)
+      if !(key = args[0]).is_a?(Symbol)
+        super
+      else
+        idx = -1
+        # Whenever a JoinHash has a value of a JoinArray with a single member then it is a wrapper, usually for a Symbol
+        matching = find { |x| idx += 1; (x.is_a?(::Brick::JoinArray) && x.first == key) || (x.is_a?(::Brick::JoinHash) && x.key?(key)) || x == key }
+        case matching
+        when ::Brick::JoinHash
+          matching[key]
+        when ::Brick::JoinArray
+          matching.first
+        else
+          ::Brick::JoinHash.new.tap do |child|
+            child.instance_variable_set(:@parent, self)
+            child.instance_variable_set(:@parent_key, key) # %%% Use idx instead of key?
+          end
+        end
+      end
+    end
+
+    def []=(*args)
+      ::Brick::JoinArray.attach_back_to_root(self, args[0], args[1])
+
+      if (key = args[0]).is_a?(Symbol) && ((value = args[1]).is_a?(::Brick::JoinHash) || value.is_a?(Symbol) || value.nil?)
+        # %%% This is for the first symbol added to a JoinArray, cleaning out the leftover {} that is temporarily built out
+        # when doing my_join_array[:value1][:value2] = nil.
+        idx = -1
+        delete_at(idx) if value.nil? && any? { |x| idx += 1; x.is_a?(::Brick::JoinHash) && x.empty? }
+
+        set_matching(key, value)
+      else
+        super
+      end
+    end
+
+    def self.attach_back_to_root(collection, key = nil, value = nil)
+      # Create a list of layers which start at the root
+      layers = []
+      layer = collection
+      while layer.parent
+        layers << layer
+        layer = layer.parent
+      end
+      # Go through the layers from root down to child, attaching everything
+      layers.each do |layer|
+        if (prnt = layer.remove_instance_variable(:@parent))
+          layer.instance_variable_set(:@orig_parent, prnt)
+        end
+        case prnt
+        when ::Brick::JoinHash
+          value = if prnt.key?(layer.parent_key)
+                    if layer.is_a?(Hash)
+                      layer
+                    else
+                      ::Brick::JoinArray.new.replace([prnt.fetch(layer.parent_key, nil), layer])
+                    end
+                  else
+                    layer
+                  end
+          # This is as if we did:  prnt[layer.parent_key] = value
+          # but calling it that way would attempt to infinitely recurse back onto this overridden version of the []= method,
+          # so we go directly to ._brick_store() instead.
+          prnt._brick_store(layer.parent_key, value)
+        when ::Brick::JoinArray
+          if (key)
+            puts "X1"
+            prnt[layer.parent_key][key] = value
+          else
+            prnt[layer.parent_key] = layer
+          end
+        end
+      end
+    end
+
+    def set_matching(key, value)
+      idx = -1
+      matching = find { |x| idx += 1; (x.is_a?(::Brick::JoinArray) && x.first == key) || (x.is_a?(::Brick::JoinHash) && x.key?(key)) || x == key }
+      case matching
+      when ::Brick::JoinHash
+        matching[key] = value
+      when Symbol
+        if value.nil? # If it already exists then no worries
+          matching
+        else
+          # Not yet there, so we will "graduate" this single value into being a key / value pair found in a JoinHash.  The
+          # destination hash to be used will be either an existing one if there is a neighbouring JoinHash available, or a
+          # newly-built one placed in the "new_hash" variable if none yet exists.
+          hash = find { |x| x.is_a?(::Brick::JoinHash) } || (new_hash = ::Brick::JoinHash.new)
+          hash._brick_store(key, ::Brick::JoinArray.new.tap { |val_array| val_array.replace([value]) })
+          # hash.instance_variable_set(:@parent, matching.parent) if matching.parent
+          # hash.instance_variable_set(:@parent_key, matching.parent_key) if matching.parent_key
+
+          # When a new JoinHash was created, we place it at the same index where the original lone symbol value was pulled from.
+          # If instead we used an existing JoinHash then since that symbol has now been graduated into a new key / value pair in
+          # the existing JoinHash then we delete the original symbol by its index.
+          new_hash ? _brick_set(idx, new_hash) : delete_at(idx)
+        end
+      when ::Brick::JoinArray # Replace this single thing (usually a Symbol found as a value in a JoinHash)
+        (hash = ::Brick::JoinHash.new)._brick_store(key, value)
+        if matching.parent
+          hash.instance_variable_set(:@parent, matching.parent)
+          hash.instance_variable_set(:@parent_key, matching.parent_key)
+        end
+        _brick_set(idx, hash)
+      else # Doesn't already exist anywhere, so add it to the end of this JoinArray and return the new member
+        if value
+          ::Brick::JoinHash.new.tap do |hash|
+            val_collection = if value.is_a?(::Brick::JoinHash)
+                               value
+                             else
+                               ::Brick::JoinArray.new.tap { |array| array.replace([value]) }
+                             end
+            val_collection.instance_variable_set(:@parent, hash)
+            val_collection.instance_variable_set(:@parent_key, key)
+            hash._brick_store(key, val_collection)
+            hash.instance_variable_set(:@parent, self)
+            hash.instance_variable_set(:@parent_key, length)
+          end
+        else
+          key
+        end.tap { |member| push(member) }
+      end
+    end
+  end
+
+  class JoinHash < Hash
+    attr_reader :parent, :orig_parent, :parent_key
+    alias _brick_store []=
+
+    def [](*args)
+      if (current = super)
+        current
+      elsif (key = args[0]).is_a?(Symbol)
+        ::Brick::JoinHash.new.tap do |child|
+          child.instance_variable_set(:@parent, self)
+          child.instance_variable_set(:@parent_key, key)
+        end
+      end
+    end
+
+    def []=(*args)
+      ::Brick::JoinArray.attach_back_to_root(self)
+
+      if !(key = args[0]).is_a?(Symbol) || (!(value = args[1]).is_a?(Symbol) && !value.nil?)
+        super # Revert to normal hash behaviour when we're not passed symbols
+      else
+        case (current = fetch(key, nil))
+        when value
+          if value.nil? # Setting a single value where nothing yet exists
+            case orig_parent
+            when ::Brick::JoinHash
+              if self.empty? # Convert this empty hash into a JoinArray
+                orig_parent._brick_store(parent_key, ::Brick::JoinArray.new.replace([key]))
+              else # Call back into []= to use our own logic, this time setting this value from the context of the parent
+                orig_parent[parent_key] = key
+              end
+            when ::Brick::JoinArray
+              orig_parent[parent_key][key] = nil
+            else # No knowledge of any parent, so all we can do is add this single value right here as { key => nil }
+              super
+            end
+            key
+          else # Setting a key / value pair where nothing yet exists
+            puts "X2"
+            super(key, ::Brick::JoinArray.new.replace([value]))
+            value
+          end
+        when Symbol # Upgrade an existing symbol to be a part of our special JoinArray
+          puts "X3"
+          super(key, ::Brick::JoinArray.new.replace([current, value]))
+        when ::Brick::JoinArray # Concatenate new stuff onto any existing JoinArray
+          current.set_matching(value, nil)
+        when ::Brick::JoinHash # Graduate an existing hash into being in an array if things are dissimilar
+          super(key, ::Brick::JoinArray.new.replace([current, value]))
+          value
+        else # Perhaps this is part of some hybrid thing
+          super(key, ::Brick::JoinArray.new.replace([value]))
+          value
+        end
+      end
+    end
+  end
+end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -102,14 +102,37 @@ module Brick
     end
 
     def get_bts_and_hms(model)
-      model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+      bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+        next if !const_defined?(a.name.to_s.singularize.camelize) && ::Brick.config.exclude_tables.include?(a.plural_name)
+
+        # So that we can map an association name to any special alias name used in an AREL query
+        ans = (model._assoc_names[a.name] ||= [])
+        ans << a.klass unless ans.include?(a.klass)
         case a.macro
         when :belongs_to
           s.first[a.foreign_key] = [a.name, a.klass]
-        when :has_many, :has_one
+        when :has_many, :has_one # This gets has_many as well as has_many :through
+          # %%% weed out ones that don't have an available model to reference
           s.last[a.name] = a
         end
       end
+      # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
+      # as well as any possible polymorphic associations
+      skip_hms = {}
+      associatives = hms.each_with_object({}) do |hmt, s|
+        if (through = hmt.last.options[:through])
+          skip_hms[through] = nil
+          s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
+        elsif hmt.last.inverse_of.nil?
+          puts "SKIPPING #{hmt.last.name.inspect}"
+          # %%% If we don't do this then below associative.name will find that associative is nil
+          skip_hms[hmt.last.name] = nil
+        end
+      end
+      skip_hms.each do |k, _v|
+        puts hms.delete(k).inspect
+      end
+      [bts, hms, associatives]
     end
 
     # Switches Brick auto-models on or off, for all threads
@@ -217,6 +240,12 @@ module Brick
       end
     end
 
+    # Skip showing counts for these specific has_many associations when building auto-generated #index views
+    # @api public
+    def skip_index_hms=(value)
+      Brick.config.skip_index_hms = value
+    end
+
     # Associations to treat as a has_one
     # @api public
     def has_ones=(hos)
@@ -254,6 +283,17 @@ module Brick
         ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2]) }
         @_additional_references_loaded = true
       end
+
+      # Find associative tables that can be set up for has_many :through
+      ::Brick.relations.each do |_key, tbl|
+        tbl_cols = tbl[:cols].keys
+        fks = tbl[:fks].each_with_object({}) { |fk, s| s[fk.last[:fk]] = [fk.last[:assoc_name], fk.last[:inverse_table]] if fk.last[:is_bt]; s }
+        # Aside from the primary key and the metadata columns created_at, updated_at, and deleted_at, if this table only has
+        # foreign keys then it can act as an associative table and thus be used with has_many :through.
+        if fks.length > 1 && (tbl_cols - fks.keys - (::Brick.config.metadata_columns || []) - (tbl[:pkey].values.first || [])).length.zero?
+          fks.each { |fk| tbl[:hmt_fks][fk.first] = fk.last }
+        end
+      end
     end
 
 

data/lib/generators/brick/install_generator.rb

@@ -18,7 +18,7 @@ module Brick
     desc 'Generates an initializer file for configuring Brick'
 
     def create_initializer_file
-      unless File.exists?(filename = 'config/initializers/brick.rb')
+      unless File.exist?(filename = 'config/initializers/brick.rb')
         # See if we can make suggestions for additional_references
         resembles_fks = []
         possible_additional_references = (relations = ::Brick.relations).each_with_object([]) do |v, s|
@@ -47,7 +47,7 @@ module Brick
               if (relations.fetch(f_table = col_down, nil) ||
                  relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
                  # Looks pretty promising ... just make sure a model file isn't present
-                 !File.exists?("app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb")
+                 !File.exist?("app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb")
                 s << "['#{v.first}', '#{col}', '#{f_table}']"
               else
                 resembles_fks << "#{v.first}.#{col}"
@@ -58,24 +58,24 @@ module Brick
         end
 
         bar = case possible_additional_references.length
-      when 0
+              when 0
 +"# Brick.additional_references = [['orders', 'customer_id', 'customer'],
 #                                ['customer', 'region_id', 'regions']]"
-      when 1
-        +"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+              when 1
++"# # Here is a possible additional reference that has been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
 # Brick.additional_references = [[#{possible_additional_references.first}]"
-      else
-        +"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
+              else
++"# # Here are possible additional references that have been auto-identified for the #{ActiveRecord::Base.connection.current_database} database:
 # Brick.additional_references = [
 #   #{possible_additional_references.join(",\n#   ")}
 # ]"
-      end
+              end
       if resembles_fks.length > 0
         bar << "\n# # Columns named somewhat like a foreign key which you may want to consider:
 # #   #{resembles_fks.join(', ')}"
       end
 
-        create_file filename, "# frozen_string_literal: true
+      create_file(filename, "# frozen_string_literal: true
 
 # # Settings for the Brick gem
 # # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
@@ -111,11 +111,16 @@ module Brick
 # # to be the primary key.)
 #{bar}
 
-# # Skip creating a has_many association for these
+# # Skip creating a has_many association for these (only retain the belongs_to built from this additional_reference).
 # # (Uses the same exact three-part format as would define an additional_reference)
 # # Say for instance that we didn't care to display the favourite colours that users have:
 # Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
 
+# # Skip showing counts for these specific has_many associations when building auto-generated #index views.
+# # When there are related tables with a significant number of records, this can lessen the load on the database
+# # considerably, sometimes fixing what might appear to be an index page that just \"hangs\" for no apparent reason.
+Brick.skip_index_hms = ['User.litany_of_woes']
+
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
 # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
 # # using the primary model name and the association name which you instead want to have treated as a \"has_one\":
@@ -159,7 +164,7 @@ module Brick
 # Brick.default_route_fallback = 'customers' # This defaults to \"customers/index\"
 # Brick.default_route_fallback = 'orders/outstanding' # Example of a non-RESTful route
 # Brick.default_route_fallback = '' # Omits setting a default route in the absence of any other
-"
+")
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.18
+  version: 1.0.21
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-27 00:00:00.000000000 Z
+date: 2022-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -221,6 +221,7 @@ files:
 - lib/brick/frameworks/rails/controller.rb
 - lib/brick/frameworks/rails/engine.rb
 - lib/brick/frameworks/rspec.rb
+- lib/brick/join_array.rb
 - lib/brick/serializers/json.rb
 - lib/brick/serializers/yaml.rb
 - lib/brick/util.rb