brick 1.0.49 → 1.0.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b42f1ad45e6dc942ed2e875d39318f8705f9a467c0cb31f267a71a01053bfd4
-  data.tar.gz: 1e8f0cd1c374c5d75be4e4f1a8b659dd32b46f991c85cce4d234a6949d017e4b
+  metadata.gz: e3d0b398d1d3926fa3e59281c976fe2f7a54bfc16de4f99683928ce71d7ace97
+  data.tar.gz: 344c0de3e8691583e9a940ee451ad29015d46b0cbc55756d3b36e10d9ce27edb
 SHA512:
-  metadata.gz: 437d415278f01a2ffced31687f77324c21416e6e7ef395d6a5d3db5a1853ccfb301c01716747ba4427417164a1200100205e7b7c75443bef83f1050f01683dda
-  data.tar.gz: d42367f291f2900876c5263aab30280f7b5b3d9f205c4199349b9e24d35326b5457e1db8fd0d39a512f59af9691bbe44e29dd05d3384d5a0013c05ffe6447d8c
+  metadata.gz: e0cff4e30c30d33dd13bd5a6a4a888d52e0552fc692369c42a53846da00e9ce677ab48ba840ef1396728d339984e5f7ff35d9ce33ea60f8421b9fa19edc14575
+  data.tar.gz: 5971fcc802dd1732f71d3bcd015e4b616f7775028a10205c7e4b9b1fa41d13c0318f581c966c223e9a0661b8b9fa52e1197ae78c007144e93ec96de61b084663

data/lib/brick/extensions.rb

@@ -221,13 +221,19 @@ module ActiveRecord
       template
     end
 
-    # belongs_to DSL descriptions
-    def self._br_bt_descrip
-      @_br_bt_descrip ||= {}
-    end
-    # has_many count definitions
-    def self._br_hm_counts
-      @_br_hm_counts ||= {}
+    class << self
+      # belongs_to DSL descriptions
+      def _br_bt_descrip
+        @_br_bt_descrip ||= {}
+      end
+      # has_many count definitions
+      def _br_hm_counts
+        @_br_hm_counts ||= {}
+      end
+      # has_many :through associative tables
+      def _br_associatives
+        @_br_associatives ||= {}
+      end
     end
 
     # Search for BT, HM, and HMT DSL stuff
@@ -374,7 +380,7 @@ module ActiveRecord
 
         case (ks = k.split('.')).length
         when 1
-          next unless klass._brick_get_fks.include?(k)
+          next unless klass.column_names.any?(k) || klass._brick_get_fks.include?(k)
         when 2
           assoc_name = ks.first.to_sym
           # Make sure it's a good association name and that the model has that column name
@@ -408,6 +414,7 @@ module ActiveRecord
         chains = rel_dupe._brick_chains
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
+        used_col_aliases = {} # Used to make sure there is not a name clash
         bt_columns = klass._br_bt_descrip.each_with_object([]) do |v, s|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
@@ -419,7 +426,12 @@ module ActiveRecord
 
               # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
               is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
-              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{(col_alias = "_brfk_#{v.first}__#{sel_col.last}")}\""
+              # If it's not unique then also include the belongs_to association name before the column name
+              if used_col_aliases.key?(col_alias = "_brfk_#{v.first}__#{sel_col.last}")
+                col_alias = "_brfk_#{v.first}__#{v1[idx][-2..-1].map(&:to_s).join('__')}"
+              end
+              selects << "\"#{field_tbl_name}\".\"#{sel_col.last}\"#{'::text' if is_xml} AS \"#{col_alias}\""
+              used_col_aliases[col_alias] = nil
               v1[idx] << col_alias
             end
 
@@ -447,8 +459,7 @@ module ActiveRecord
       klass._br_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 if fk_col
+                         hm.foreign_key if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
@@ -502,7 +513,7 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
     end
 
   private
-  
+
     def shift_or_first(ary)
       ary.length > 1 ? ary.shift : ary.first
     end
@@ -536,12 +547,23 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
                               this_module.const_set(module_name.to_sym, Module.new)
                             end
             end
-            if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
-              this_module.const_get(class_name)
-            else
-              # Build STI subclass and place it into the namespace module
-              this_module.const_set(class_name, klass = Class.new(self))
-              klass
+            begin
+              if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
+                this_module.const_get(class_name)
+              else
+                # Build STI subclass and place it into the namespace module
+                this_module.const_set(class_name, klass = Class.new(self))
+                klass
+              end
+            rescue NameError => err
+              if column_names.include?(inheritance_column)
+                puts "Table #{table_name} has column #{inheritance_column} which ActiveRecord expects to use as its special inheritance column."
+                puts "Unfortunately the value \"#{type_name}\" does not seem to refer to a valid type name, greatly confusing matters.  If that column is intended to be used for data and not STI, consider putting this line into your Brick initializer so that only for this table that column will not clash with ActiveRecord:"
+                puts "  Brick.sti_type_column = { 'rails_#{inheritance_column}' => ['#{table_name}'] }"
+                self
+              else
+                raise
+              end
             end
           end
         end
@@ -592,6 +614,8 @@ Module.class_exec do
       return possible
     end
     class_name = args.first.to_s
+    # self.name is nil when a model name is requested in an .erb file
+    base_module = (self < ActiveRecord::Migration || !self.name) ? Object : self
     # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
     # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
     # that is, checking #qualified_name_for with:  from_mod, const_name
@@ -599,14 +623,17 @@ Module.class_exec do
     # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
     # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
     # If the file really exists, go and snag it:
-    if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = (self.name || class_name)&.split('::'))
-      filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
-    end
-    if is_found
-      return self._brick_const_missing(*args)
-    # elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
-    #   my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
-    #   return my_const
+    if ActiveSupport::Dependencies.search_for_file(class_name.underscore)
+      return base_module._brick_const_missing(*args)
+      # elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
+      #   my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
+      #   return my_const
+    else
+      filepath = base_module.name&.split('::')&.[](0..-2) unless base_module == Object
+      filepath = ((filepath || []) + [class_name]).join('/').underscore + '.rb'
+      if ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
+        return base_module._brick_const_missing(*args)
+      end
     end
 
     relations = ::Brick.relations
@@ -625,7 +652,7 @@ Module.class_exec do
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
              elsif (::Brick.enable_models? || ::Brick.enable_controllers?) && # Schema match?
-                   self == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
+                   base_module == Object && # %%% This works for Person::Person -- but also limits us to not being able to allow more than one level of namespacing
                    (schema_name = [(singular_table_name = class_name.underscore),
                                    (table_name = singular_table_name.pluralize),
                                    class_name,
@@ -633,7 +660,7 @@ Module.class_exec do
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
                # Build out a module for the schema if it's namespaced
                # schema_name = schema_name.camelize
-               self.const_set(schema_name.to_sym, (built_module = Module.new))
+               base_module.const_set(schema_name.to_sym, (built_module = Module.new))
 
                [built_module, "module #{schema_name}; end\n"]
                #  # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
@@ -643,8 +670,8 @@ Module.class_exec do
                # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
                # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
 
-               if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{self.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
-                  self != Object # ... or otherwise already in some namespace?
+               if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+                  base_module != Object # ... or otherwise already in some namespace?
                  schema_name = [(singular_schema_name = name.underscore),
                                 (schema_name = singular_schema_name.pluralize),
                                 name,
@@ -657,7 +684,7 @@ Module.class_exec do
                if base_model
                  schema_name = name.underscore # For the auto-STI namespace models
                  table_name = base_model.table_name
-                 Object.send(:build_model, self, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
+                 Object.send(:build_model, base_module, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
                else
                  # Adjust for STI if we know of a base model for the requested model name
                  # %%% Does not yet work with namespaced model names.  Perhaps prefix with plural_class_name when doing the lookups here.
@@ -682,15 +709,15 @@ Module.class_exec do
       built_class
     elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}") && !schema_name
 #         module_prefixes = type_name.split('::')
-#         path = self.name.split('::')[0..-2] + []
+#         path = base_module.name.split('::')[0..-2] + []
 #         module_prefixes.unshift('') unless module_prefixes.first.blank?
 #         candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
-      self._brick_const_missing(*args)
-    # elsif self != Object
+      base_module._brick_const_missing(*args)
+    # elsif base_module != Object
     #   module_parent.const_missing(*args)
     else
-      puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
-      self._brick_const_missing(*args)
+      puts "MISSING! #{base_module.name} #{args.inspect} #{table_name}"
+      base_module._brick_const_missing(*args)
     end
   end
 end
@@ -831,15 +858,15 @@ class Object
                              "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
                            else # Use BT names to provide uniqueness
                              if self.name.underscore.singularize == hm.first[:alternate_name]
-                              #  Has previously been:
-                              # # If it folds back on itself then look at the other side
-                              # # (At this point just infer the source be the inverse of the first has_many that
-                              # # we find that is not ourselves.  If there are more than two then uh oh, can't
-                              # # yet handle that rare circumstance!)
-                              # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
-                              # options[:source] = other.first[:inverse][:assoc_name].to_sym
-                              #  And also has been:
-                              # hm.first[:inverse][:assoc_name].to_sym
+                               #  Has previously been:
+                               # # If it folds back on itself then look at the other side
+                               # # (At this point just infer the source be the inverse of the first has_many that
+                               # # we find that is not ourselves.  If there are more than two then uh oh, can't
+                               # # yet handle that rare circumstance!)
+                               # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
+                               # options[:source] = other.first[:inverse][:assoc_name].to_sym
+                               #  And also has been:
+                               # hm.first[:inverse][:assoc_name].to_sym
                                options[:source] = hm.last.to_sym
                              else
                                through = hm.first[:alternate_name].pluralize
@@ -1097,9 +1124,7 @@ class Object
         is_pk_string = nil
         if (pk_col = model&.primary_key)
           code << "  def show\n"
-          code << (find_by_id = "    id = params[:id]&.split(/[\\/,_]/)
-    id = id.first if id.is_a?(Array) && id.length == 1
-    @#{singular_table_name} = #{model.name}.find(id)\n")
+          code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
           code << "  end\n"
           self.define_method :show do
             ::Brick.set_db_schema(params)
@@ -1110,25 +1135,47 @@ class Object
                    params[:id]&.split(/[\/,_]/)
                  end
             id = id.first if id.is_a?(Array) && id.length == 1
-            instance_variable_set("@#{singular_table_name}".to_sym, model.find(id))
+            instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
           end
         end
 
         # By default, views get marked as read-only
-        unless is_swagger # model.readonly # (relation = relations[model.table_name]).key?(:isView)
-          code << "  # (Define :new, :create)\n"
+        # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
+          code << "  def new\n"
+          code << "    @#{singular_table_name} = #{model.name}.new\n"
+          code << "  end\n"
+          self.define_method :new do
+            ::Brick.set_db_schema(params)
+            instance_variable_set("@#{singular_table_name}".to_sym, model.new)
+          end
+
+          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
 
-          if model.primary_key
+          code << "  def create\n"
+          code << "    @#{singular_table_name} = #{model.name}.create(#{params_name})\n"
+          code << "  end\n"
+          self.define_method :create do
+            ::Brick.set_db_schema(params)
+            instance_variable_set("@#{singular_table_name}".to_sym,
+                                  model.send(:create, send(params_name_sym)))
+          end
+
+          if pk_col
             # if (schema = ::Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil)) && ::Brick.db_schemas&.include?(schema)
             #   ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
             # end
 
             is_need_params = true
-            # code << "  # (Define :edit, and :destroy)\n"
+            code << "  def edit\n"
+            code << "    #{find_by_name}\n"
+            code << "  end\n"
+            self.define_method :edit do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+            end
+
             code << "  def update\n"
-            code << find_by_id
-            params_name = "#{singular_table_name}_params"
-            code << "    @#{singular_table_name}.update(#{params_name})\n"
+            code << "    #{find_by_name}.update(#{params_name})\n"
             code << "  end\n"
             self.define_method :update do
               ::Brick.set_db_schema(params)
@@ -1147,27 +1194,50 @@ class Object
               #   return
               end
 
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = find_obj))
+              obj.send(:update, send(params_name_sym))
+            end
+
+            code << "  def destroy\n"
+            code << "    #{find_by_name}.destroy\n"
+            code << "  end\n"
+            self.define_method :destroy do
+              ::Brick.set_db_schema(params)
+              instance_variable_set("@#{singular_table_name}".to_sym, find_obj.send(:destroy))
+            end
+          end
+
+          code << "private\n" if pk_col || is_need_params
+
+          if pk_col
+            code << "  def find_#{singular_table_name}
+    id = params[:id]&.split(/[\\/,_]/)
+    @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+  end\n"
+            self.define_method :find_obj do
               id = is_pk_string ? params[:id] : params[:id]&.split(/[\/,_]/)
-              id = id.first if id.is_a?(Array) && id.length == 1
-              instance_variable_set("@#{singular_table_name}".to_sym, (obj = model.find(id)))
-              obj = obj.first if obj.is_a?(Array)
-              obj.send(:update, send(params_name = params_name.to_sym))
+              model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
             end
           end
 
           if is_need_params
-            code << "private\n"
             code << "  def #{params_name}\n"
+            permits = model.columns_hash.keys.map(&:to_sym)
+            permits_txt = permits.map(&:inspect) +
+                          model.reflect_on_all_associations.select { |assoc| assoc.macro == :has_many && assoc.options[:through] }.map do |assoc|
+                            permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
+                            "#{assoc.name.to_s.singularize}_ids: []"
+                          end
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
-                             }).permit(#{model.columns_hash.keys.map { |c| c.to_sym.inspect }.join(', ')})\n"
+                             }).permit(#{permits_txt.join(', ')})\n"
             code << "  end\n"
             self.define_method(params_name) do
-              params.require(require_name.to_sym).permit(model.columns_hash.keys)
+              params.require(require_name.to_sym).permit(permits)
             end
             private params_name
             # Get column names for params from relations[model.table_name][:cols].keys
           end
-        end
+        # end
         code << "end # #{namespace_name}#{class_name}\n\n"
       end # class definition
       [built_controller, code]

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

@@ -58,7 +58,9 @@ module Brick
             def template_exists?(*args, **options)
               (::Brick.config.add_orphans && args.first == 'orphans') ||
               _brick_template_exists?(*args, **options) ||
-              set_brick_model(args)
+              # Do not auto-create a template when it's searching for an application.html.erb, which comes in like:  ["edit", ["games", "application"]]
+              ((args[1].length == 1 || args[1][-1] != 'application') &&
+               set_brick_model(args))
             end
 
             def set_brick_model(find_args)
@@ -104,7 +106,7 @@ module Brick
                 path_obj_name = model_name.underscore.tr('/', '_')
                 table_name = obj_name.pluralize
                 template_link = nil
-                bts, hms, associatives = ::Brick.get_bts_and_hms(@_brick_model) # This gets BT and HM and also has_many :through (HMT)
+                bts, hms = ::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|
@@ -112,7 +114,7 @@ module Brick
                               "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if hm_assoc.options[:through]
-                                 associative = associatives[hm.first]
+                                 associative = @_brick_model._br_associatives[hm.first]
                                  tbl_nm = if hm_assoc.options[:source]
                                             associative.klass.reflect_on_association(hm_assoc.options[:source]).inverse_of&.name
                                           else
@@ -131,25 +133,21 @@ module Brick
                   case args.first
                   when 'index'
                     hms_columns << if hm_assoc.macro == :has_many
-                                     set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
-                                                'nil'
-                                              else
-                                                # Postgres column names are limited to 63 characters
-                                                attrib_name = "_br_#{assoc_name}_ct"[0..62]
-                                                "#{obj_name}.#{attrib_name} || 0"
-                                              end
                                      if hm_fk_name
-"<%= ct = #{set_ct}
-     link_to \"#\{ct || 'View'\} #{assoc_name}\", #{hm_assoc.klass.name.underscore.tr('/', '_').pluralize}_path({ #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)} }) unless ct&.zero? %>\n"
+                                       set_ct = if skip_klass_hms.key?(assoc_name.to_sym)
+                                                   'nil'
+                                                 else
+                                                   # Postgres column names are limited to 63 characters
+                                                   attrib_name = "_br_#{assoc_name}_ct"[0..62]
+                                                   "#{obj_name}.#{attrib_name} || 0"
+                                                 end
+                                       "#{hm_assoc.name}: [#{assoc_name.inspect}, #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}]"
                                      else # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-"#{assoc_name}\n"
+                                       "#{hm_assoc.name}: [#{assoc_name.inspect}]"
                                      end
                                    else # has_one
                                      # 0..62 because Postgres column names are limited to 63 characters
-"<%= descrips = @_brick_bt_descrip[#{hm.first.inspect}][ho_class = #{hm[1].klass.name}]
-     ho_txt = ho_class.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
-     ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
-     ho_id&.first ? link_to(ho_txt, send(\"#\{ho_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt %>\n"
+                                     "#{hm_assoc.name}: [#{assoc_name.inspect}, nil, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}]"
                                    end
                   when 'show', 'update'
                     hm_stuff << if hm_fk_name
@@ -166,12 +164,12 @@ module Brick
               # %%% 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
               apartment_default_schema = ::Brick.apartment_multitenant && Apartment.default_schema
-              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).map do |tbl|
+              table_options = (::Brick.relations.keys - ::Brick.config.exclude_tables).each_with_object({}) do |tbl, s|
                                 if (tbl_parts = tbl.split('.')).first == apartment_default_schema
                                   tbl = tbl_parts.last
                                 end
-                                tbl
-                              end.sort.each_with_object(+'') do |v, s|
+                                s[tbl] = nil
+                              end.keys.sort.each_with_object(+'') do |v, s|
                                 s << "<option value=\"#{v.underscore.gsub('.', '/').pluralize}\">#{v}</option>"
                               end.html_safe
               table_options << '<option value="brick_orphans">(Orphans)</option>'.html_safe if is_orphans
@@ -283,8 +281,8 @@ input+svg.revert {
   color: #FFF;
 }
 </style>
-<% is_includes_dates = nil
 
+<% is_includes_dates = nil
 def is_bcrypt?(val)
   val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
 end
@@ -553,46 +551,46 @@ if (headerTop) {
 <br>
 <table id=\"headerTop\">
 <table id=\"#{table_name}\">
-  <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%
+  <thead><tr>#{"<th x-order=\"#{pk.join(',')}\"></th>" if pk.present?}<%=
      col_order = []
-     @#{table_name}.columns.each do |col|
-       next if (#{(pk || []).inspect}.include?(col_name = col.name) && col.type == :integer && !bts.key?(col_name)) ||
-               ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
-
-       col_order << col_name
-    %><th<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %><%
-       if (bt = bts[col_name]) %>
-         <%= \" x-order=\\\"#\{bt.first}\\\"\".html_safe if true # Currently we always allow click to sort
-         %>>BT <%
-         bt[1].each do |bt_pair| %><%=
-           bt_pair.first.bt_link(bt.first) %> <%
-         end %><%
-       else %><%= \" x-order=\\\"#\{col_name}\\\"\".html_safe if true # Currently we always allow click to sort
-         %>><%= col_name %><%
-       end
-    %></th><%
-     end
      # Consider getting the name from the association -- h.first.name -- if a more \"friendly\" alias should be used for a screwy table name
-  %>#{hms_headers.map do |h|
-        # Currently we always allow click to sort
-        "<th#{" x-order=\"#{h.first.name}\"" if true}>" +
-        if h.first.options[:through] && !h.first.through_reflection
-    "#{h[1]} #{h[2]} %></th>" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
-        else
-    "#{h[1]} <%= link_to('#{h[2]}', #{h.first.klass.name.underscore.tr('/', '_').pluralize}_path) %></th>"
-        end
-      end.join
-  }</tr></thead>
-
+     hms_hdrs = {#{hms_headers.map do |hm|
+                    "#{hm.first.name}: [#{hm.first.name.inspect}, #{(hm.first.options[:through] && !hm.first.through_reflection).inspect}, #{hm.first.klass.name}, #{hm[1].inspect}, #{hm[2].inspect}]"
+                  end.join(', ')}}
+     (@#{table_name}.columns + hms_hdrs.values).each_with_object(+'') do |col, s|
+       if col.is_a?(ActiveRecord::ConnectionAdapters::Column)
+         next if (#{(pk || []).inspect}.include?(col_name = col.name) && col.type == :integer && !bts.key?(col_name)) ||
+                 ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
+
+         col_order << col_name
+         s << if (bt = bts[col_name])
+                \"<th#\{' x-order=\"' + bt.first.to_s + '\"' unless bt[2]}>BT \" + # Allow sorting any BT except polymorphics
+                bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
+              else
+                # Currently we always allow click to sort on non-BT columns
+                \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col_name}\"
+              end + '</th>'
+       else # Currently we always allow click to sort on all HM columns (col is the hm array)
+         col_order << col.first # hm.name
+         s << \"<th#\{' x-order=\"' + col.first.to_s + '\"' if true}>\"
+         s << if col[1]
+                \"#\{col[3]} #\{col[4]}\" # %%% Would be able to remove this when multiple foreign keys to same destination becomes bulletproof
+              else
+                \"#\{col[3]} #\{link_to(col[4], send(\"#\{col[2].name.underscore.tr('/', '_').pluralize}_path\"))}\"
+              end + '</th>'
+       end
+     end.html_safe
+  %></tr></thead>
   <tbody>
-  <% @#{table_name}.each do |#{obj_name}| %>
+  <% @#{table_name}.each do |#{obj_name}|
+       hms_cols = {#{hms_columns.join(', ')}} %>
   <tr>#{"
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% col_order.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
-      <td>
-      <% if (bt = bts[col_name]) %>
-        <% if bt[2] # Polymorphic?
+      <td><%
+         if (bt = bts[col_name])
+           if bt[2] # Polymorphic?
              bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
              base_class = (::Brick.existing_stis[bt_class] || bt_class).constantize.base_class.name.underscore
              poly_id = #{obj_name}.send(\"#\{bt.first\}_id\")
@@ -608,12 +606,26 @@ if (headerTop) {
           <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, bt_id)) : bt_txt %>
           <%#= Previously was:  bt_obj = bt[1].first.first.find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt[1].first.first.name.underscore\}_path\".to_sym, bt_obj.send(bt[1].first.first.primary_key.to_sym))) if bt_obj %>
         <% end %>
-      <% else %>
-        <%= hide_bcrypt(val) %>
-      <% end %>
-      </td>
+      <% elsif (hms_col = hms_cols[col_name])
+           if hms_col.length == 1 %>
+         <%= hms_col.first %>
+        <% else
+             klass = (col = hms_hdrs[col_name])[2]
+             txt = if col[3] == 'HO'
+                     descrips = @_brick_bt_descrip[col_name][klass]
+                     ho_txt = klass.brick_descrip(#{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (ho_id_col = descrips.last))
+                     ho_id = ho_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) }
+                     ho_id&.first ? link_to(ho_txt, send(\"#\{klass.base_class.name.underscore.tr('/', '_')\}_path\".to_sym, ho_id)) : ho_txt
+                   else
+                     \"#\{hms_col[1] || 'View'\} #\{hms_col.first}\"
+                   end %>
+         <%= link_to txt, send(\"#\{klass.name.underscore.tr('/', '_').pluralize}_path\".to_sym, hms_col[2]) unless hms_col[1]&.zero? %>
+        <% end %>
+      <% else
+      %><%= hide_bcrypt(val) %><%
+         end
+    %></td>
     <% end %>
-    #{hms_columns.each_with_object(+'') { |hm_col, s| s << "<td>#{hm_col}</td>" }}
   </tr>
   <% end %>
   </tbody>
@@ -807,7 +819,9 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
    # %%% Create a smart javascript routine which can do this client-side %>
 [... document.getElementsByTagName(\"TH\")].forEach(function (th) {
   th.addEventListener(\"click\", function (e) {
-    location.href = changeout(location.href, \"_brick_order\", this.getAttribute(\"x-order\"));
+    var xOrder;
+    if (xOrder = this.getAttribute(\"x-order\"))
+      location.href = changeout(location.href, \"_brick_order\", xOrder);
   });
 });
 document.querySelectorAll(\"input, select\").forEach(function (inp) {

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -172,14 +172,14 @@ module Brick
       # 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|
+      hms.each do |hmt|
         if (through = hmt.last.options[:through])
           skip_hms[through] = nil # if hms[through]
           # binding.pry if !hms[through]
           # End up with a hash of HMT names pointing to join-table associations
           # Last part was:  hmt.last.name
           # Changed up because looking for:  hms[:issue_issue_duplicates]
-          s[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
+          model._br_associatives[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
         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
@@ -187,7 +187,7 @@ module Brick
         end
       end
       skip_hms.each { |k, _v| hms.delete(k) }
-      [bts, hms, associatives]
+      [bts, hms]
     end
 
     # Switches Brick auto-models on or off, for all threads

metadata

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