brick 1.0.74 → 1.0.76

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7f077a36e2fd62546cdebfde2b9651807ceeaad9571008460423d9e994df44d
-  data.tar.gz: 368ca31e726fa377325b7ff7838e38cd6b79aa222bcec73cdd6cebc645908d28
+  metadata.gz: 615640b22db113a3959644ee9c2d08ff3a2b37aa10f12dc92d68effef091c228
+  data.tar.gz: b0d3e616b0f44584cf6960f8b8b191fc449b9afc426a6486da11c2deadece7a6
 SHA512:
-  metadata.gz: a4154837ca3926cb1cd8d4803d62a789f1aa6449625560c63c06708508543e218765288d13a763aab238ea946dfdc33391454793b02805a8cdf46f729cf436da
-  data.tar.gz: 599cd989ef47a99cb0b6b4cb1a1c53da892d5758ccd208ecb4bf1383a2f29c1bc4600458c4de357e5496f90f664984c10634f469a40f80bcc89a9e5592735899
+  metadata.gz: 02a9f1c74af24e1e23df8b64972d7af8d74bbb870f1510b69d0814f362959e2527f2a7ee9ff7ca65187eb97be4fad1136d64bea7e01a8327a57608924a8f12d8
+  data.tar.gz: '0265977b746d0955c76bef269067d14363cda4373fc5f726f19fb284baf31d0df3bdaae6ffad7301b71cd630a2745db4d30f1da79ec43ef4ae1a92bc986058e9'

data/lib/brick/config.rb

@@ -90,6 +90,15 @@ module Brick
       @mutex.synchronize { @additional_references = references }
     end
 
+    # Custom columns to add to a table, minimally defined with a name and DSL string
+    def custom_columns
+      @mutex.synchronize { @custom_columns }
+    end
+
+    def custom_columns=(cust_cols)
+      @mutex.synchronize { @custom_columns = cust_cols }
+    end
+
     # Skip creating a has_many association for these
     def exclude_hms
       @mutex.synchronize { @exclude_hms }

data/lib/brick/extensions.rb

@@ -100,73 +100,86 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, emit_dsl = false, is_polymorphic = false)
-      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)
+    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
+      unless build_array.is_a?(::Brick::JoinArray)
+        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)
+      end
+      prefix = [prefix] unless prefix.is_a?(Array)
       members = []
+      unless dsl || (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
+        # 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.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
+        return members
+      end
+
+      # Do the actual dirty work of recursing through nested DSL
       bracket_name = nil
-      prefix = [prefix] unless prefix.is_a?(Array)
-      if (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
-        dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
-        dsl3 = +'' # To return expanded DSL that is nested from another model
-        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 do |part|
-                klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
-                puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
-                part_sym
-              end
-              parts = prefix + first_parts + [parts[-1]]
-              if parts.length > 1
-                unless is_polymorphic
-                  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
-                end
-                translations[parts[0..-2].join('.')] = klass
+      dsl2 = +'' # To replace our own DSL definition in case it needs to be expanded
+      dsl3 = +'' # To return expanded DSL that is nested from another model
+      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 do |part|
+              klass = (orig_class = klass).reflect_on_association(part_sym = part.to_sym)&.klass
+              puts "Couldn't reference #{orig_class.name}##{part} that's part of the DSL \"#{dsl}\"." if klass.nil?
+              part_sym
+            end
+            parts = prefix + first_parts + [parts[-1]]
+            if parts.length > 1
+              unless is_polymorphic
+                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
               end
-              if klass.column_names.exclude?(parts.last) &&
-                 (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
-                # Expand this entry which refers to an association name
-                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, true)
-                members += members2
-                dsl2 << dsl2a
-                dsl3 << dsl2a
-              else
-                dsl2 << "[#{bracket_name}]"
-                if emit_dsl
-                  dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
-                end
-                members << parts
+              translations[parts[0..-2].join('.')] = klass
+            end
+            if klass.column_names.exclude?(parts.last) &&
+               (klass = (orig_class = klass).reflect_on_association(possible_dsl = parts.pop.to_sym)&.klass)
+              if prefix.empty? # Custom columns start with an empty prefix
+                prefix << parts.shift until parts.empty?
               end
-              bracket_name = nil
+              # Expand this entry which refers to an association name
+              members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
+              members += members2
+              dsl2 << dsl2a
+              dsl3 << dsl2a
             else
-              bracket_name << ch
+              dsl2 << "[#{bracket_name}]"
+              if emit_dsl
+                dsl3 << "[#{prefix[1..-1].map { |p| "#{p.to_s}." }.join if prefix.length > 1}#{bracket_name}]"
+              end
+              members << parts
             end
-          elsif ch == '['
-            bracket_name = +''
-            klass = self
+            bracket_name = nil
           else
-            dsl2 << ch
-            dsl3 << ch
+            bracket_name << ch
           end
+        elsif ch == '['
+          bracket_name = +''
+          klass = self
+        else
+          dsl2 << ch
+          dsl3 << ch
         end
-        # Rewrite the DSL in case it's now different from having to expand it
-        # if ::Brick.config.model_descrips[name] != dsl2
-        #   puts ::Brick.config.model_descrips[name]
-        #   puts dsl2.inspect
-        #   puts dsl3.inspect
-        #   binding.pry
-        # end
-        ::Brick.config.model_descrips[name] = dsl2 unless emit_dsl
-      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.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
       end
-      emit_dsl ? [members, dsl3] : members
+      # Rewrite the DSL in case it's now different from having to expand it
+      # if ::Brick.config.model_descrips[name] != dsl2
+      #   puts ::Brick.config.model_descrips[name]
+      #   puts dsl2.inspect
+      #   puts dsl3.inspect
+      #   binding.pry
+      # end
+      if emit_dsl
+        # Had been:  [members, dsl2, dsl3]
+        [members, dsl3]
+      else
+        ::Brick.config.model_descrips[name] = dsl2
+        members
+      end
     end
 
     # If available, parse simple DSL attached to a model in order to provide a friendlier name.
@@ -177,7 +190,8 @@ module ActiveRecord
     end
 
     def self.brick_descrip(obj, data = nil, pk_alias = nil)
-      if (dsl = ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
+      dsl = obj if obj.is_a?(String)
+      if (dsl ||= ::Brick.config.model_descrips[(klass = self).name] || klass.brick_get_dsl)
         idx = -1
         caches = {}
         output = +''
@@ -235,7 +249,7 @@ module ActiveRecord
 
     def self.bt_link(assoc_name)
       assoc_name = CGI.escapeHTML(assoc_name.to_s)
-      model_path = Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
+      model_path = ::Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
       av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
       av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('7')
       link = av_class.link_to(name, model_path)
@@ -272,18 +286,28 @@ module ActiveRecord
       def _br_associatives
         @_br_associatives ||= {}
       end
+      # Custom columns
+      def _br_cust_cols
+        @_br_cust_cols ||= {}
+      end
     end
 
-    # Search for BT, HM, and HMT DSL stuff
+    # Search for custom column, BT, HM, and HMT DSL stuff
     def self._brick_calculate_bts_hms(translations, join_array)
+      # Add any custom columns
+      ::Brick.config.custom_columns&.fetch(table_name, nil)&.each do |k, cc|
+        # false = not polymorphic, and true = yes -- please emit_dsl
+        pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, cc, true)
+        _br_cust_cols[k] = [pieces, my_dsl]
+      end
       bts, hms, associatives = ::Brick.get_bts_and_hms(self)
       bts.each do |_k, bt|
         next if bt[2] # Polymorphic?
 
         # join_array will receive this relation name when calling #brick_parse_dsl
         _br_bt_descrip[bt.first] = if bt[1].is_a?(Array)
-                                     # Last two params here:  "false" is for don't emit DSL, and "true" is for yes, we are polymorphic
-                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, false, true) }
+                                     # Last params here:  "true" is for yes, we are polymorphic
+                                     bt[1].each_with_object({}) { |bt_class, s| s[bt_class] = bt_class.brick_parse_dsl(join_array, bt.first, translations, true) }
                                    else
                                      { bt.last => bt[1].brick_parse_dsl(join_array, bt.first, translations) }
                                    end
@@ -314,7 +338,7 @@ module ActiveRecord
                    else # Expecting only Symbol
                      if _br_hm_counts.key?(ord_part)
                        ord_part = "\"b_r_#{ord_part}_ct\""
-                     elsif !_br_bt_descrip.key?(ord_part) && !column_names.include?(ord_part.to_s)
+                     elsif !_br_bt_descrip.key?(ord_part) && !_br_cust_cols.key?(ord_part) && !column_names.include?(ord_part.to_s)
                        # Disallow ordering by a bogus column
                        # %%% Note this bogus entry so that Javascript can remove any bogus _brick_order
                        # parameter from the querystring, pushing it into the browser history.
@@ -331,6 +355,11 @@ module ActiveRecord
       [order_by, order_by_txt]
     end
 
+    def self.brick_select(params = {}, selects = [], *args)
+      (relation = all).brick_select(params, selects, *args)
+      relation.select(selects)
+    end
+
   private
 
     def self._brick_get_fks
@@ -421,7 +450,13 @@ module ActiveRecord
       end
     end
 
-    def brick_select(params, selects = nil, order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+    def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+      is_add_bts = is_add_hms = true
+
+      # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
+      # model early in case the user wants to do an ORDER BY based on any of that.
+      model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
+
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ActiveRecord::Base.connection.adapter_name == 'Mysql2'
       is_mssql = ActiveRecord::Base.connection.adapter_name == 'SQLServer'
@@ -446,7 +481,7 @@ module ActiveRecord
       end
 
       # %%% Skip the metadata columns
-      if selects&.empty? # Default to all columns
+      if selects.empty? # Default to all columns
         tbl_no_schema = table.name.split('.').last
         # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
         #     ActiveRecord::StatementInvalid (TinyTds::Error: DBPROCESS is dead or not enabled)
@@ -481,7 +516,36 @@ module ActiveRecord
         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|
+
+        # CUSTOM COLUMNS
+        # ==============
+        klass._br_cust_cols.each do |k, cc|
+          if respond_to?(k) # Name already taken?
+            # %%% Use ensure_unique here in this kind of fashion:
+            # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+            # binding.pry
+            next
+          end
+
+          cc.first.each do |cc_part|
+            dest_klass = cc_part[0..-2].inject(klass) { |kl, cc_part_term| kl.reflect_on_association(cc_part_term).klass }
+            tbl_name = (field_tbl_names[k][cc_part.last] ||= shift_or_first(chains[dest_klass])).split('.').last
+            # Deal with the conflict if there are two parts in the custom column named the same,
+            # "category.name" and "product.name" for instance will end up with aliases of "name"
+            # and "product__name".
+            cc_part_idx = cc_part.length - 1
+            while cc_part_idx > 0 &&
+                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__')}") &&
+                  used_col_aliases.key?(col_alias)
+              cc_part_idx -= 1
+            end
+            selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
+            cc_part << col_alias
+            used_col_aliases[col_alias] = nil
+          end
+        end
+
+        klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next if chains[k1].nil?
 
@@ -544,7 +608,13 @@ module ActiveRecord
       klass._br_hm_counts.each do |k, hm|
         associative = nil
         count_column = if hm.options[:through]
-                         hm.foreign_key if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
+                         if (fk_col = (associative = klass._br_associatives&.[](hm.name))&.foreign_key)
+                           if hm.source_reflection.macro == :belongs_to # Traditional HMT using an associative table
+                             hm.foreign_key
+                           else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
+                             hm.source_reflection.active_record.primary_key
+                           end
+                         end
                        else
                          fk_col = hm.foreign_key
                          poly_type = hm.inverse_of.foreign_type if hm.options.key?(:as)
@@ -596,7 +666,8 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
       end
       where!(wheres) unless wheres.empty?
       # Must parse the order_by and see if there are any symbols which refer to BT associations
-      # as they must be expanded to find the corresponding b_r_model__column naming for each.
+      # or custom columns as they must be expanded to find the corresponding b_r_model__column
+      # or br_cc_column naming for each.
       if order_by.present?
         final_order_by = *order_by.each_with_object([]) do |v, s|
           if v.is_a?(Symbol)
@@ -605,6 +676,8 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
               bt_cols.values.each do |v1|
                 v1.each { |v2| s << "\"#{v2.last}\"" if v2.length > 1 }
               end
+            elsif (cc_cols = klass._br_cust_cols[v])
+              cc_cols.first.each { |v1| s << "\"#{v1.last}\"" if v1.length > 1 }
             else
               s << v
             end
@@ -641,7 +714,7 @@ JOIN (SELECT #{selects.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}
           module_prefixes.unshift('') unless module_prefixes.first.blank?
           module_name = module_prefixes[0..-2].join('::')
           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'))
+             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
@@ -710,13 +783,17 @@ end
 Module.class_exec do
   alias _brick_const_missing const_missing
   def const_missing(*args)
-    if (self.const_defined?(args.first) && (possible = self.const_get(args.first)) && possible != self) ||
-       (self != Object && Object.const_defined?(args.first) &&
-         (
-           (possible = Object.const_get(args.first)) &&
-           (possible != self || (possible == self && possible.is_a?(Class)))
-         )
-       )
+    desired_classname = (self == Object) ? args.first.to_s : "#{name}::#{args.first}"
+    if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) && possible.name == desired_classname) ||
+       # Try to require the respective Ruby file
+       ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
+                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = args.first.to_s).underscore))
+        ) && (require_dependency(filename) || true) &&
+        ((possible = self.const_get(args.first)) && possible.name == desired_classname)
+       ) ||
+       # If any class has turned up so far (and we're not in the middle of eager loading)
+       # then return what we've found.
+       (is_defined && !::Brick.is_eager_loading)
       return possible
     end
     class_name = ::Brick.namify(args.first.to_s)
@@ -766,7 +843,7 @@ Module.class_exec do
                    (schema_name = [(singular_table_name = class_name.underscore),
                                    (table_name = singular_table_name.pluralize),
                                    ::Brick.is_oracle ? class_name.upcase : class_name,
-                                   (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas.include?(s) }&.camelize ||
+                                   (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas&.include?(s) }&.camelize ||
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name))
                return self.const_get(schema_name) if self.const_defined?(schema_name)
 
@@ -789,7 +866,7 @@ Module.class_exec do
 #         module_prefixes = type_name.split('::')
 #         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')
+#         candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
       base_module._brick_const_missing(*args)
     # elsif base_module != Object
     #   module_parent.const_missing(*args)
@@ -811,7 +888,7 @@ class Object
         schema_name = [(singular_schema_name = base_name.underscore),
                        (schema_name = singular_schema_name.pluralize),
                        base_name,
-                       base_name.pluralize].find { |s| Brick.db_schemas.include?(s) }
+                       base_name.pluralize].find { |s| Brick.db_schemas&.include?(s) }
       end
       plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
       # If it's namespaced then we turn the first part into what would be a schema name
@@ -1200,22 +1277,6 @@ class Object
             return
           end
 
-          # Normal (non-swagger) request
-
-          # We do all of this now so that bt_descrip and hm_counts are available on the model early in case the user
-          # wants to do an ORDER BY based on any of that
-          translations = {}
-          join_array = ::Brick::JoinArray.new
-          is_add_bts = is_add_hms = true
-          # This builds out bt_descrip and hm_counts on the model
-          model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
-
-          # %%% Allow params to define which columns to use for order_by
-          # Overriding the default by providing a querystring param?
-          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
-
-          ::Brick.set_db_schema(params)
           if request.format == :csv # Asking for a template?
             require 'csv'
             exported_csv = CSV.generate(force_quotes: false) do |csv_out|
@@ -1229,7 +1290,16 @@ class Object
             return
           end
 
-          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by, translations, join_array)
+          # Normal (not swagger or CSV) request
+
+          # %%% Allow params to define which columns to use for order_by
+          # Overriding the default by providing a querystring param?
+          ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+          order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
+
+          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), nil,
+                                                                  translations = {},
+                                                                  join_array = ::Brick::JoinArray.new)
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
           counts = model._br_hm_counts.each_with_object([]) do |v, s|
@@ -1434,6 +1504,27 @@ module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
     conn = _brick_establish_connection(*args)
+      # Overwrite SQLite's #begin_db_transaction so it opens in IMMEDIATE mode instead of
+      # the default DEFERRED mode.
+      #   https://discuss.rubyonrails.org/t/failed-write-transaction-upgrades-in-sqlite3/81480/2
+      if ActiveRecord::Base.connection.adapter_name == 'SQLite'
+        arca = ::ActiveRecord::ConnectionAdapters
+        db_statements = arca::SQLite3::DatabaseStatements
+        # Rails 7.1 and later
+        if arca::AbstractAdapter.private_instance_methods.include?(:with_raw_connection)
+          db_statements.define_method(:begin_db_transaction) do
+            log("begin immediate transaction", "TRANSACTION") do
+              with_raw_connection(allow_retry: true, uses_transaction: false) do |conn|
+                conn.transaction(:immediate)
+              end
+            end
+          end
+        else # Rails < 7.1
+          db_statements.define_method(:begin_db_transaction) do
+            log('begin immediate transaction', 'TRANSACTION') { @connection.transaction(:immediate) }
+          end
+        end
+      end
     begin
       _brick_reflect_tables
     rescue ActiveRecord::NoDatabaseError
@@ -1447,13 +1538,13 @@ module ActiveRecord::ConnectionHandling
     initializer_loaded = false
     if (relations = ::Brick.relations).empty?
       # If there's schema things configured then we only expect our initializer to be named exactly this
-      if File.exist?(brick_initializer = Rails.root.join('config/initializers/brick.rb'))
+      if File.exist?(brick_initializer = ::Rails.root.join('config/initializers/brick.rb'))
         initializer_loaded = load brick_initializer
       end
       # Load the initializer for the Apartment gem a little early so that if .excluded_models and
       # .default_schema are specified then we can work with non-tenanted models more appropriately
       apartment = Object.const_defined?('Apartment')
-      if apartment && File.exist?(apartment_initializer = Rails.root.join('config/initializers/apartment.rb'))
+      if apartment && File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
         load apartment_initializer
         apartment_excluded = Apartment.excluded_models
       end
@@ -1877,9 +1968,7 @@ module Brick
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
         pri_tbl = is_class ? fk[4][:class].underscore : pri_tbl
         pri_tbl = "#{bt_assoc_name}_#{pri_tbl}" if pri_tbl&.singularize != bt_assoc_name
-        cnstr_base = cnstr_name = "(brick) #{for_tbl}_#{pri_tbl}"
-        cnstr_added_num = 1
-        cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
+        cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
         missing = []
         missing << fk[1] unless relations.key?(fk[1])
         missing << primary_table unless is_class || relations.key?(primary_table)
@@ -1980,14 +2069,7 @@ module Brick
                        end
                      end
                    end
-      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
-         ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
-        Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
-      else
-        Zeitwerk::Loader.eager_load_all
-      end
-      abstract_activerecord_bases = ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
-      # abstract_activerecord_bases << ActiveRecord::Base
+      abstract_activerecord_bases = ::Brick.eager_load_classes(true)
       models = if Dir.exist?(model_path = "#{rails_root}/app/models")
                  Dir["#{model_path}/**/*.rb"].each_with_object({}) do |v, s|
                    File.read(v).split("\n").each do |line|
@@ -2011,6 +2093,28 @@ module Brick
       ::Brick.relations.keys.map { |v| [(r = v.pluralize), (model = models[r])&.last&.table_name || v, migrations&.fetch(r, nil), model&.first] }
     end
 
+    def ensure_unique(name, *sources)
+      base = name
+      if (added_num = name.slice!(/_(\d+)$/))
+        added_num = added_num[1..-1].to_i
+      else
+        added_num = 1
+      end
+      while (
+        name = "#{base}_#{added_num += 1}"
+        sources.each_with_object(nil) do |v, s|
+          s || case v
+               when Hash
+                 v.key?(name)
+               when Array
+                 v.include?(name)
+               end
+        end
+      )
+      end
+      name
+    end
+
     # Locate orphaned records
     def find_orphans(multi_schema)
       is_default_schema = multi_schema&.==(Apartment.default_schema)

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

@@ -33,6 +33,9 @@ module Brick
         # Additional references (virtual foreign keys)
         ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
 
+        # Custom columns to add to a table, minimally defined with a name and DSL string
+        ::Brick.custom_columns = app.config.brick.fetch(:custom_columns, nil)
+
         # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
         ::Brick.order = app.config.brick.fetch(:order, {})
 
@@ -72,7 +75,6 @@ module Brick
             def set_brick_model(find_args)
               # Need to return true if we can fill in the blanks for a missing one
               # args will be something like:  ["index", ["categories"]]
-              find_args[1] = find_args[1].each_with_object([]) { |a, s| s.concat(a.split('/')) }
               if (class_name = find_args[1].last&.singularize)
                 find_args[1][find_args[1].length - 1] = class_name # Make sure the last item, defining the class name, is singular
                 if (model = find_args[1].map(&:camelize).join('::').constantize) && (
@@ -100,10 +102,13 @@ module Brick
             def find_template(*args, **options)
               unless (model_name = @_brick_model&.name) ||
                      (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
-                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']]) ||
-                     # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
-                     (model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name)
-                return _brick_find_template(*args, **options)
+                     (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']])
+                if (possible_template = _brick_find_template(*args, **options))
+                  return possible_template
+                else
+                  # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
+                  model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name
+                end
               end
 
               if @_brick_model
@@ -247,8 +252,8 @@ tr th {
   right: 0;
   cursor: pointer;
 }
-#headerTop tr th:hover {
-  background-color: #18B090;
+#headerTop tr th:hover, #headerTop tr th.highlight {
+  background-color: #28B898;
 }
 #exclusions {
   font-size: 0.7em;
@@ -271,6 +276,10 @@ tr th, tr td {
   padding: 0.2em 0.5em;
 }
 
+tr td.highlight {
+  background-color: #B0B0FF;
+}
+
 .show-field {
   background-color: #004998;
 }
@@ -498,6 +507,34 @@ function changeout(href, param, value, trimAfter) {
 var grid = document.getElementById(\"#{table_name}\");
 #{table_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
 var headerTop = document.getElementById(\"headerTop\");
+var headerCols;
+if (grid) {
+  // COLUMN HEADER AND TABLE CELL HIGHLIGHTING
+  var gridHighHeader = null,
+      gridHighCell = null;
+  grid.addEventListener(\"mouseenter\", gridMove);
+  grid.addEventListener(\"mousemove\", gridMove);
+  grid.addEventListener(\"mouseleave\", function (evt) {
+    if (gridHighCell) gridHighCell.classList.remove(\"highlight\");
+    gridHighCell = null;
+    if (gridHighHeader) gridHighHeader.classList.remove(\"highlight\");
+    gridHighHeader = null;
+  });
+  function gridMove(evt) {
+    var lastHighCell = gridHighCell;
+    gridHighCell = document.elementFromPoint(evt.x, evt.y);
+    if (lastHighCell !== gridHighCell) {
+      gridHighCell.classList.add(\"highlight\");
+      if (lastHighCell) lastHighCell.classList.remove(\"highlight\");
+    }
+    var lastHighHeader = gridHighHeader;
+    gridHighHeader = headerCols[gridHighCell.cellIndex];
+    if (lastHighHeader !== gridHighHeader) {
+      if (gridHighHeader) gridHighHeader.classList.add(\"highlight\");
+      if (lastHighHeader) lastHighHeader.classList.remove(\"highlight\");
+    }
+  }
+}
 function setHeaderSizes() {
   // console.log(\"start\");
   // See if the headerTop is already populated
@@ -529,6 +566,7 @@ function setHeaderSizes() {
         }
       }
     }
+    headerCols = tr.childNodes;
     if (isEmpty) headerTop.appendChild(tr);
   }
   grid.style.marginTop = \"-\" + getComputedStyle(headerTop).height;
@@ -777,7 +815,8 @@ erDiagram
        cols[col_name] = col
      end
      unless @_brick_sequence # If no sequence is defined, start with all inclusions
-       @_brick_sequence = col_keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
+       cust_cols = #{model_name}._br_cust_cols
+       @_brick_sequence = col_keys + cust_cols.keys + #{(hms_keys).inspect}.reject { |assoc_name| @_brick_incl&.exclude?(assoc_name) }
      end
      @_brick_sequence.reject! { |nm| @_brick_excl.include?(nm) } if @_brick_excl # Reject exclusions
      @_brick_sequence.each_with_object(+'') do |col_name, s|
@@ -794,6 +833,8 @@ erDiagram
        elsif col # HM column
          s << \"<th#\{' x-order=\"' + col_name + '\"' if true}>#\{col[2]} \"
          s << (col.first ? \"#\{col[3]}\" : \"#\{link_to(col[3], send(\"#\{col[1]._brick_index}_path\"))}\")
+       elsif (cc = cust_cols.key?(col_name)) # Custom column
+         s << \"<th x-order=\\\"#\{col_name}\\\">#\{col_name}\"
        else # Bad column name!
          s << \"<th title=\\\"<< Unknown column >>\\\">#\{col_name}\"
        end
@@ -811,7 +852,7 @@ erDiagram
     <td><%= link_to '⇛', #{path_obj_name}_path(#{obj_pk}), { class: 'big-arrow' } %></td>" if obj_pk}
     <% @_brick_sequence.each do |col_name|
          val = #{obj_name}.attributes[col_name] %>
-      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name)%>><%
+      <td<%= ' class=\"dimmed\"'.html_safe unless cols.key?(col_name) || (cust_col = cust_cols[col_name])%>><%
          if (bt = bts[col_name])
            if bt[2] # Polymorphic?
              bt_class = #{obj_name}.send(\"#\{bt.first\}_type\")
@@ -845,6 +886,9 @@ erDiagram
          elsif (col = cols[col_name])
            col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
     %><%=  display_value(col_type || col&.sql_type, val) %><%
+         elsif cust_col
+           data = cust_col.first.map { |cc_part| #{obj_name}.send(cc_part.last) }
+    %><%=  #{model_name}.brick_descrip(cust_col.last, data) %><%
          else # Bad column name!
       %>?<%
          end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -123,7 +123,7 @@ module Brick
   end
 
   class << self
-    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle
+    attr_accessor :default_schema, :db_schemas, :routes_done, :is_oracle, :is_eager_loading
 
     def set_db_schema(params = nil)
       schema = (params ? params['_brick_schema'] : ::Brick.default_schema) || 'public'
@@ -329,6 +329,15 @@ module Brick
       end
     end
 
+    # Custom columns to add to a table, minimally defined with a name and DSL string.
+    # @api public
+    def custom_columns=(cust_cols)
+      if cust_cols
+        cust_cols = cust_cols.call if cust_cols.is_a?(Proc)
+        Brick.config.custom_columns = cust_cols
+      end
+    end
+
     # @api public
     def order=(value)
       Brick.config.order = value
@@ -495,6 +504,21 @@ In config/initializers/brick.rb appropriate entries would look something like:
       VERSION::STRING
     end
 
+    def eager_load_classes(do_ar_abstract_bases = false)
+      ::Brick.is_eager_loading = true
+      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
+         ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
+        ::Rails.configuration.eager_load_namespaces.select { |ns| ns < ::Rails::Application }.each(&:eager_load!)
+      else
+        Zeitwerk::Loader.eager_load_all
+      end
+      abstract_ar_bases = if do_ar_abstract_bases
+                            ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
+                          end
+      ::Brick.is_eager_loading = false
+      abstract_ar_bases
+    end
+
     def display_classes(rels, max_length)
       rels.sort.each do |rel|
         puts "#{rel.first}#{' ' * (max_length - rel.first.length)}  /#{rel.last}"
@@ -593,12 +617,12 @@ require 'active_record/relation/query_methods' if ActiveRecord.version < ::Gem::
 require 'rails/railtie' if ActiveRecord.version < ::Gem::Version.new('4.2')
 
 # Rake tasks
-class Railtie < Rails::Railtie
+class Railtie < ::Rails::Railtie
   Dir.glob("#{File.expand_path(__dir__)}/brick/tasks/**/*.rake").each { |task| load task }
 end
 
 # Rails < 4.2 does not have env
-module Rails
+module ::Rails
   unless respond_to?(:env)
     def self.env
       @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")

data/lib/generators/brick/install_generator.rb

@@ -207,6 +207,12 @@ module Brick
 # # to be the primary key.)
 #{bar}
 
+# # Custom columns to add to a table, minimally defined with a name and DSL string.
+# Brick.custom_columns = { 'users' =>  { messages:    ['[COUNT(messages)] messages', 'messages'] },
+#                          'orders' => { salesperson:  '[salesperson.first] [salesperson.last]',
+#                                        products:    ['[COUNT(order_items.product)] products', 'order_items.product' ] }
+#                        }
+
 # # 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:

data/lib/generators/brick/migrations_generator.rb

@@ -55,7 +55,7 @@ module Brick
       # If Apartment is active, see if a default schema to analyse is indicated
 
       # # Load all models
-      # Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+      # ::Brick.eager_load_classes
 
       if (tables = ::Brick.relations.reject { |k, v| v.key?(:isView) && v[:isView] == true }.map(&:first).sort).empty?
         puts "No tables found in database #{ActiveRecord::Base.connection.current_database}."

data/lib/generators/brick/models_generator.rb

@@ -16,12 +16,7 @@ module Brick
       # %%% If Apartment is active and there's no schema_to_analyse, ask which schema they want
 
       # Load all models
-      if ::ActiveSupport.version < ::Gem::Version.new('6') ||
-        ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
-        Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
-      else
-        Zeitwerk::Loader.eager_load_all
-      end
+      ::Brick.eager_load_classes
 
       # Generate a list of viable models that can be chosen
       longest_length = 0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.74
+  version: 1.0.76
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-27 00:00:00.000000000 Z
+date: 2022-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord