brick 1.0.139 → 1.0.141

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e13ace06f3c894715f631be750cd0571b9ab1cfe44b15780e9278d7b6a1c88f3
-  data.tar.gz: fd0d89eb66a8878fc968e95e7a3c27f1fcf619a06c652c0c58c468d4cf66e451
+  metadata.gz: 9f2d0e5e8ee3fb56acdbdee808b2a6ebe8cbf8b43457fd10b46f6197d82ef054
+  data.tar.gz: f21cca0ba332706e77d7f21245aeef6aa922668fbd41020e4edecd6672fdf4e0
 SHA512:
-  metadata.gz: 58665ea6c29d49542ae83096fa3ad5fa371ed0a12920f86492111319e3ab9a46c8c7d83ab9277377b6dabb51a75adf0a7cb32c4aa37234f54d796fe206563172
-  data.tar.gz: f5ee7ebdfa31f76133db652ff0beec175aa5eb319a7f1472da56f0e8e7c79aba12bceb9c26b73fc4c305e69143529416cb5d683660025d1b1e08aa72209a688b
+  metadata.gz: b2a88167018d956d7066eaae2bb0fa05e69a1efe751b725477a6b13ad575fad7e89237fc1749138533723103f1a63018a23f6ba83cb1b6bed972e22c3bb89321
+  data.tar.gz: a6fc5f155686488fac49aea2eb58bc734021ea2be01fd505acbe29c357f888f65b17ebea78bae4c22ce83e4847eaef456c8a5329193753b8ac756a724d998ed1

data/lib/brick/compatibility.rb

@@ -26,6 +26,7 @@ if Object.const_defined?('ActionPack') && !ActionPack.respond_to?(:version)
     end
   end
 end
+require 'action_view' # Needed for Rails <= 4.0
 if Object.const_defined?('ActionView') && !ActionView.respond_to?(:version)
   module ActionView
     def self.version

data/lib/brick/config.rb

@@ -347,6 +347,14 @@ module Brick
       @mutex.synchronize { @not_nullables = columns }
     end
 
+    def always_load_fields
+      @mutex.synchronize { @always_load_fields || {} }
+    end
+
+    def always_load_fields=(field_set)
+      @mutex.synchronize { @always_load_fields = field_set }
+    end
+
     # Add status page showing all resources and what files have been built out for them
     def add_status
       true

data/lib/brick/extensions.rb

@@ -82,7 +82,7 @@ module ActiveRecord
 
       def json_column?(col)
         col.type == :json || ::Brick.config.json_columns[table_name]&.include?(col.name) ||
-        ((attr_types = attribute_types[col.name]).respond_to?(:coder) &&
+        (respond_to?(:attribute_types) && (attr_types = attribute_types[col.name]).respond_to?(:coder) &&
          (attr_types.coder.is_a?(Class) ? attr_types.coder : attr_types.coder&.class)&.name&.end_with?('JSON'))
       end
     end
@@ -235,7 +235,7 @@ module ActiveRecord
                                        caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
                                      rescue
                                        clsnm = part.camelize
-                                       if (possible = this_obj.class.reflect_on_all_associations.select { |a| a.class_name == clsnm || a.klass.base_class.name == clsnm }.first)
+                                       if (possible = this_obj.class.reflect_on_all_associations.select { |a| !a.polymorphic? && (a.class_name == clsnm || a.klass.base_class.name == clsnm) }.first)
                                          caches[obj_name] = this_obj&.send(possible.name)
                                        end
                                      end
@@ -286,7 +286,7 @@ module ActiveRecord
       assoc_html_name = unless (assoc_name = assoc_name.to_s).camelize == name
                           CGI.escapeHTML(assoc_name)
                         end
-      model_path = ::Rails.application.routes.url_helpers.send("#{_brick_index}_path".to_sym)
+      model_path = ::Rails.application.routes.url_helpers.send("#{_brick_index || table_name}_path".to_sym)
       model_path << "?#{self.inheritance_column}=#{self.name}" if self != base_class
       av_class = Class.new.extend(ActionView::Helpers::UrlHelper)
       av_class.extend(ActionView::Helpers::TagHelper) if ActionView.version < ::Gem::Version.new('7')
@@ -296,6 +296,8 @@ module ActiveRecord
 
     # Providing a relation object allows auto-modules built from table name prefixes to work
     def self._brick_index(mode = nil, separator = '_', relation = nil)
+      return if abstract_class?
+
       tbl_parts = ((mode == :singular) ? table_name.singularize : table_name).split('.')
       tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
       if (aps = relation&.fetch(:auto_prefixed_schema, nil)) && tbl_parts.last.start_with?(aps)
@@ -352,7 +354,7 @@ module ActiveRecord
         pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, cc, true)
         _br_cust_cols[k] = [pieces, my_dsl, fk_col]
       end
-      bts, hms, associatives = ::Brick.get_bts_and_hms(self)
+      bts, hms, associatives = ::Brick.get_bts_and_hms(self, true)
       bts.each do |_k, bt|
         next if bt[2] # Polymorphic?
 
@@ -431,8 +433,16 @@ module ActiveRecord
       [order_by, order_by_txt]
     end
 
-    def self.brick_select(params = {}, selects = [], *args)
-      (relation = all).brick_select(params, selects, *args)
+    def self.brick_select(*args, params: {}, brick_col_names: false, **kwargs)
+      selects = if args[0].is_a?(Array)
+                  other_args = args[1..-1]
+                  args[0]
+                else
+                  other_args = []
+                  args
+                end
+      (relation = all).brick_select(selects, *other_args,
+                                    params: params, brick_col_names: brick_col_names, **kwargs)
       relation.select(selects)
     end
 
@@ -472,10 +482,29 @@ module ActiveRecord
       @brick_links ||= { '' => table_name }
     end
 
-    def brick_select(params, selects = [], order_by = nil, translations = {},
-                     join_array = ::Brick::JoinArray.new,
-                     cust_col_override = nil)
-      is_add_bts = is_add_hms = true
+    def brick_select(*args, params: {}, order_by: nil, translations: {},
+                     join_array: ::Brick::JoinArray.new,
+                     cust_col_override: nil,
+                     brick_col_names: true)
+      selects = args[0].is_a?(Array) ? args[0] : args
+      if selects.present? && cust_col_override.nil? # See if there's any fancy ones in the select list
+        idx = 0
+        while idx < selects.length
+          v = selects[idx]
+          if v.is_a?(String) && v.index('.')
+            # No prefixes and not polymorphic
+            pieces = self.brick_parse_dsl(join_array, [], translations, false, dsl = "[#{v}]")
+            (cust_col_override ||= {})[v.tr('.', '_').to_sym] = [pieces, dsl, true]
+            selects.delete_at(idx)
+          else
+            idx += 1
+          end
+        end
+      elsif selects.is_a?(Hash) && params.empty? && cust_col_override.nil? # Make sense of things if they've passed in only params
+        params = selects
+        selects = []
+      end
+      is_add_bts = is_add_hms = !cust_col_override
 
       # 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.
@@ -487,6 +516,7 @@ module ActiveRecord
       is_distinct = nil
       wheres = {}
       params.each do |k, v|
+        k = k.to_s # Rails < 4.2 comes in as a symbol
         next if ['_brick_schema', '_brick_order',
                  '_brick_erd', '_brick_exclude', '_brick_unexclude',
                  '_brick_page', '_brick_page_size', '_brick_offset', '_brick_limit',
@@ -544,9 +574,24 @@ module ActiveRecord
                        "'<#{typ.end_with?('_TYP') ? typ[0..-5] : typ}>' AS #{col.name}"
                      end
         end
+      else # Having some select columns chosen, add any missing always_load_fields for this model ...
+        this_model = klass
+        loop do
+          ::Brick.config.always_load_fields.fetch(this_model.name, nil)&.each do |alf|
+            selects << alf unless selects.include?(alf)
+          end
+          # ... plus any and all STI superclasses it may inherit from
+          break if (this_model = this_model.superclass).abstract_class? || this_model == ActiveRecord::Base
+        end
       end
 
-      left_outer_joins!(join_array) if join_array.present?
+      if join_array.present?
+        if ActiveRecord.version < Gem::Version.new('4.2')
+          joins!(join_array)
+        else
+          left_outer_joins!(join_array)
+        end
+      end
 
       # If it's a CollectionProxy (which inherits from Relation) then need to dig out the
       # core Relation object which is found in the association scope.
@@ -594,11 +639,13 @@ module ActiveRecord
           # 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".
+          col_prefix = 'br_cc_' if brick_col_names
           if (cc_part_idx = cc_part.length - 1).zero?
-            col_alias = "br_cc_#{k}__#{table_name.tr('.', '_')}_#{cc_part.first}"
-          else
+            col_alias = "#{col_prefix}#{k}__#{table_name.tr('.', '_')}_#{cc_part.first}"
+          elsif brick_col_names ||
+                used_col_aliases.key?(col_alias = k.to_s) # This sets a simpler custom column name if possible
             while cc_part_idx > 0 &&
-                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
+                  (col_alias = "#{col_prefix}#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
                   used_col_aliases.key?(col_alias)
               cc_part_idx -= 1
             end
@@ -611,7 +658,7 @@ module ActiveRecord
             key_tbl_name = tbl_name
             cc_part_idx = cc_part.length - 1
             while cc_part_idx > 0 &&
-                  (key_alias = "br_cc_#{k}__#{(cc_part[cc_part_idx..-2] + [dest_pk]).map(&:to_s).join('__')}") &&
+                  (key_alias = "#{col_prefix}#{k}__#{(cc_part[cc_part_idx..-2] + [dest_pk]).map(&:to_s).join('__')}") &&
                   key_alias != col_alias && # We break out if this key alias does exactly match the col_alias
                   used_col_aliases.key?(key_alias)
               cc_part_idx -= 1
@@ -781,7 +828,7 @@ module ActiveRecord
 
         pri_tbl = hm.active_record
         pri_key = hm.options[:primary_key] || pri_tbl.primary_key
-        unless hm.active_record.column_names.include?(pri_key)
+        if hm.active_record.abstract_class || hm.active_record.column_names.exclude?(pri_key)
           # %%% When this gets hit then if an attempt is made to display the ERD, it might end up being blank
           nix << k
           next
@@ -907,21 +954,60 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
       # Get foreign keys for anything marked to be auto-preloaded, or a self-referencing JOIN
       klass_cols = klass.column_names
       reflect_on_all_associations.each do |a|
-        selects << a.foreign_key if a.belongs_to? && (preload_values.include?(a.name) ||
-                                    (!a.options[:polymorphic] && a.klass == klass && klass_cols.include?(a.foreign_key)))
+        selects << a.foreign_key if a.belongs_to? &&
+                                    (preload_values.include?(a.name) ||
+                                     (!a.options[:polymorphic] && a.klass == klass && klass_cols.include?(a.foreign_key))
+                                    )
       end
       # ActiveStorage compatibility
       selects << 'service_name' if klass.name == 'ActiveStorage::Blob' && ActiveStorage::Blob.columns_hash.key?('service_name')
       selects << 'blob_id' if klass.name == 'ActiveStorage::Attachment' && ActiveStorage::Attachment.columns_hash.key?('blob_id')
       pieces, my_dsl = klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
       brick_select(
-        where_values_hash, selects, nil, translations, join_array,
-        { '_br' => (descrip_cols = [pieces, my_dsl]) }
+        selects, where_values_hash, nil, translations: translations, join_array: join_array,
+        cust_col_override: { '_br' => (descrip_cols = [pieces, my_dsl]) }
       )
-      order_values = klass.primary_key
+      order_values = "#{klass.table_name}.#{klass.primary_key}"
       [self.select(selects), descrip_cols]
     end
 
+    # Accommodate when a relation gets queried for a model, and in that model it has an #after_initialize block
+    # which references attributes that were not originally included as part of the select_values.
+    def brick_(method, *args, brick_orig_relation: nil, **kwargs, &block)
+      begin
+        send(method, *args, **kwargs, &block) # method will be something like :uniq or :each
+      rescue ActiveModel::MissingAttributeError => e
+        if (err_msg = e.message).start_with?('missing attribute: ') &&
+           klass.column_names.include?(col_name = e.message[19..-1])
+          (dup_rel = dup).select_values << col_name
+          ret = dup_rel.brick_(method, *args, brick_orig_relation: (brick_orig_relation ||= self), **kwargs, &block)
+          always_loads = (::Brick.config.always_load_fields ||= {})
+
+          # Find the most parent STI superclass for this model, and apply an always_load_fields entry for this missing column
+          has_field = false
+          this_model = klass
+          loop do
+            has_field = true if always_loads.key?(this_model.name) && always_loads[this_model.name]&.include?(col_name)
+            break if has_field || (next_model = this_model.superclass).abstract_class? || next_model == ActiveRecord::Base
+            this_model = next_model
+          end
+          unless has_field
+            (brick_orig_relation || self).instance_variable_set(:@brick_new_alf, ((always_loads[this_model.name] ||= []) << col_name))
+          end
+
+          if self.object_id == brick_orig_relation.object_id
+            puts "*** WARNING: Missing field#{'s' if @brick_new_alf.length > 1}!
+Might want to add this in your brick.rb:
+  ::Brick.always_load_fields = { #{klass.name.inspect} => #{@brick_new_alf.inspect} }"
+            remove_instance_variable(:@brick_new_alf)
+          end
+          ret
+        else
+          []
+        end
+      end
+    end
+
   private
 
     def shift_or_first(ary)
@@ -935,6 +1021,8 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
 
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
+        return if type_name.is_a?(Numeric)
+
         if ::Brick.sti_models.key?(type_name ||= name)
           ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
         else
@@ -1606,7 +1694,7 @@ class Object
 
         # Add a hash for the inline style to the content-security-policy if one is present
         self.define_method(:add_csp_hash) do |style_value = nil|
-          if (csp = request.content_security_policy)
+          if request.respond_to?(:content_security_policy) && (csp = request.content_security_policy)
             if (cspd = csp.directives.fetch('style-src'))
               if style_value
                 if (nonce = ::ActionDispatch::ContentSecurityPolicy::Request::NONCE)
@@ -1850,9 +1938,9 @@ class Object
 
             ar_relation = ActiveRecord.version < Gem::Version.new('4') ? real_model.preload : real_model.all
             params['_brick_is_api'] = true if (is_api = request.format == :js || current_api_root)
-            @_brick_params = ar_relation.brick_select(params, (selects ||= []), order_by,
-                                                      translations = {},
-                                                      join_array = ::Brick::JoinArray.new)
+            @_brick_params = ar_relation.brick_select((selects ||= []), params: params, order_by: order_by,
+                                                      translations: (translations = {}),
+                                                      join_array: (join_array = ::Brick::JoinArray.new))
 
             if is_api # Asking for JSON?
               # Apply column renaming

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

@@ -209,11 +209,15 @@ function linkSchemas() {
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
       config.brick = ActiveSupport::OrderedOptions.new
       ActiveSupport.on_load(:before_initialize) do |app|
-        ::Rails.application.reloader.to_prepare { Module.class_exec &::Brick::ADD_CONST_MISSING }
+        if ::Rails.application.respond_to?(:reloader)
+          ::Rails.application.reloader.to_prepare { Module.class_exec &::Brick::ADD_CONST_MISSING }
+        else # For Rails < 5.0, just load it once at the start
+          Module.class_exec &::Brick::ADD_CONST_MISSING
+        end
+        require 'brick/join_array'
         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, 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)
@@ -599,12 +603,14 @@ window.addEventListener(\"popstate\", linkSchemas);
         # ====================================
         if ::Brick.enable_views?
           # Add the params to the lookup_context so that we have context about STI classes when setting @_brick_model
-          ActionView::ViewPaths.class_exec do
-            alias :_brick_lookup_context :lookup_context
-            def lookup_context(*args)
-              ret = _brick_lookup_context(*args)
-              @_lookup_context.instance_variable_set(:@_brick_req_params, params)
-              ret
+          if ActionView.const_defined?('ViewPaths')
+            ActionView::ViewPaths.class_exec do
+              alias :_brick_lookup_context :lookup_context
+              def lookup_context(*args)
+                ret = _brick_lookup_context(*args)
+                @_lookup_context.instance_variable_set(:@_brick_req_params, params)
+                ret
+              end
             end
           end
 
@@ -679,11 +685,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                 rescue StandardError => e
                   # Search through the routes to confirm that something might match (Devise stuff for instance, which has its own view templates),
                   # and bubble the same exception (probably an ActionView::MissingTemplate) if a legitimate option is found.
-                  raise if ::Rails.application.routes.set.find { |x| args[1].include?(x.defaults[:controller]) && args[0] == x.defaults[:action] }
+                  raise if ::Rails.application.routes.set.find { |x| args[1].include?(x.defaults[:controller]) && args[0] == x.defaults[:action] } &&
+                           ActionView.version >= ::Gem::Version.new('5.0')
 
                   find_template_err = e
                 end
-                # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
                 model_name = set_brick_model(args, @_brick_req_params)&.name
               end
 
@@ -741,7 +747,7 @@ window.addEventListener(\"popstate\", linkSchemas);
                                      (hm_fk_name.is_a?(String) && hm_fk_name.include?('.')) # HMT?  (Could do a better check for this)
                                     predicates = path_keys(hm_assoc, hm_fk_name, pk).map do |k, v|
                                                    if v == '[sti_type]'
-                                                     "'#{k}': (@#{obj_name}.#{hm_assoc.active_record.inheritance_column}).constantize.base_class.name"
+                                                     "'#{k}': (@#{obj_name}.#{hm_assoc.active_record.inheritance_column})&.constantize&.base_class&.name"
                                                    else
                                                      v.is_a?(String) ? "'#{k}': '#{v}'" : "'#{k}': @#{obj_name}.#{v}"
                                                    end
@@ -1462,7 +1468,7 @@ end
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Status</h1>
-<table id=\"status\" class=\"shadow\"><thead><tr>
+<table id=\"resourceName\" class=\"shadow\"><thead><tr>
   <th>Resource</th>
   <th>Table</th>
   <th>Migration</th>
@@ -1481,7 +1487,11 @@ end
             kls = Object.const_get(::Brick.relations.fetch(r[0], nil)&.fetch(:class_name, nil))
           rescue
           end
-          kls.is_a?(Class) ? link_to(r[0], send(\"#\{kls._brick_index}_path\".to_sym)) : r[0] %></td>
+          if kls.is_a?(Class) && (path_helper = respond_to?(bi_path = \"#\{kls._brick_index}_path\".to_sym) ? bi_path : nil)
+            link_to(r[0], send(path_helper))
+          else
+            r[0]
+          end %></td>
   <td<%= if r[1]
            ' class=\"orphan\"' unless ::Brick.relations.key?(r[1])
          else
@@ -1541,9 +1551,11 @@ end
   base_model = (model = (obj = @#{obj_name})&.class).base_class
   see_all_path = send(\"#\{base_model._brick_index}_path\")
 #{(inh_col = @_brick_model.inheritance_column).present? &&
-"  if obj.respond_to?(:#{inh_col}) && (model_name = @#{obj_name}.#{inh_col}) != base_model.name
+"  if obj.respond_to?(:#{inh_col}) && (model_name = @#{obj_name}.#{inh_col}) &&
+     !model_name.is_a?(Numeric) && model_name != base_model.name
     see_all_path << \"?#{inh_col}=#\{model_name}\"
-  end"}
+  end
+  model_name = base_model.name if model_name.is_a?(Numeric)"}
   page_title = (\"#\{model_name ||= model.name}: #\{obj&.brick_descrip || controller_name}\")
 %></title>
 </head>
@@ -1636,8 +1648,8 @@ end
         if bt.length < 4
           bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
           # %%% Accommodate composite keys for obj.pk at the end here
-          collection, descrip_cols = bt_class&.order(obj_pk = bt_class.primary_key)&.brick_list
-          collection&.each do |obj|
+          collection, descrip_cols = bt_class&.order(Arel.sql(\"#\{bt_class.table_name}.#\{obj_pk = bt_class.primary_key}\"))&.brick_list
+          collection&.brick_(:each) do |obj|
             option_detail << [
               obj.brick_descrip(
                 descrip_cols&.first&.map { |col| obj.send(col.last) },
@@ -1717,14 +1729,21 @@ end
         else # We get an array back when AR < 4.2
           collection2 = collection.to_a.compact
         end
-        collection2 = collection2.uniq
+        collection2 = collection2.brick_(:uniq)
         if collection2.empty? %>
           <tr><td>(none)</td></tr>
      <% else
           collection2.each do |br_#{hm_singular_name}| %>
-            <tr><td><%= br_descrip = br_#{hm_singular_name}.brick_descrip(
-                                       descrip_cols&.first&.map { |col| br_#{hm_singular_name}.send(col.last) }
-                                     )
+            <tr><td><%= br_descrip = if br_#{hm_singular_name}.respond_to?(descrip_cols&.first&.first&.last)
+                                       br_#{hm_singular_name}.brick_descrip(
+                                         descrip_cols&.first&.map { |col| br_#{hm_singular_name}.send(col.last) }
+                                       )
+                                     else # If the HM association has a scope, might not have picked up our SELECT detail
+                                       pks = (klass = br_#{hm_singular_name}.class).primary_key
+                                       pks = [pks] unless pks.is_a?(Array)
+                                       pks.map! { |pk| br_#{hm_singular_name}.send(pk).to_s }
+                                       \"#\{klass.name} ##\{pks.join(', ')}\"
+                                     end
                         link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(br_#{obj_pk}))) %></td></tr>
           <% end %>
         <% end %>

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -56,7 +56,7 @@ if (is_ruby_2_7 = (ruby_version = ::Gem::Version.new(RUBY_VERSION)) >= ::Gem::Ve
   # end
 end
 
-# Add left_outer_join! to Associations::JoinDependency and Relation::QueryMethods
+# Add left_outer_joins! to Associations::JoinDependency and Relation::QueryMethods
 if ActiveRecord.version >= ::Gem::Version.new('4') && ActiveRecord.version < ::Gem::Version.new('5')
   ::Brick::Util._patch_require(
     'active_record/associations/join_dependency.rb', '/activerecord', # /associations
@@ -84,7 +84,7 @@ if ActiveRecord.version >= ::Gem::Version.new('4') && ActiveRecord.version < ::G
      ['build_joins(arel, joins_values.flatten) unless joins_values.empty?',
     "build_joins(arel, joins_values.flatten) unless joins_values.empty?
       build_left_outer_joins(arel, left_outer_joins_values.flatten) unless left_outer_joins_values.empty?"
-    ],
+     ],
      # Change 2 - Line 992
      ["raise 'unknown class: %s' % join.class.name
         end
@@ -99,8 +99,8 @@ if ActiveRecord.version >= ::Gem::Version.new('4') && ActiveRecord.version < ::G
    def build_join_query(manager, buckets, join_type)"
      ],
      # Change 3 - Line 1012
-    ['join_infos = join_dependency.join_constraints stashed_association_joins',
-    'join_infos = join_dependency.join_constraints stashed_association_joins, join_type'
+     ['s = join_dependency.join_constraints stashed_association_joins',
+      's = join_dependency.join_constraints stashed_association_joins, join_type'
      ]
     ],
     :QueryMethods
@@ -202,7 +202,11 @@ module Brick
       end
     end
 
-    def get_bts_and_hms(model)
+    def get_bts_and_hms(model, recalculate = nil)
+      if !recalculate && (ret = model.instance_variable_get(:@_brick_bts_and_hms))
+        return ret
+      end
+
       model_cols = model.columns_hash
       pk_type = if (mpk = model.primary_key).is_a?(Array)
                   # Composite keys should really use:  model.primary_key.map { |pk_part| model_cols[pk_part].type }
@@ -228,8 +232,24 @@ module Brick
               # This will come up when using Devise invitable when invited_by_class_name is not
               # specified because in that circumstance it adds a polymorphic :invited_by association,
               # along with appropriate invited_by_type and invited_by_id columns.
-              puts "Missing any real indication as to which models \"has_many\" this polymorphic BT in model #{a.active_record.name}:"
-              puts "  belongs_to :#{a.name}, polymorphic: true"
+
+              # See if any currently-loaded models have a has_many association over to this polymorphic belongs_to
+              hm_models = ActiveRecord::Base.descendants.select do |m|
+                m.reflect_on_all_associations.any? { |assoc| !assoc.belongs_to? && assoc.options[:as]&.to_sym == a.name }
+              end
+              # No need to include subclassed models if their parent is already in the list
+              hm_models.reject! { |m| hm_models.any? { |parent| parent != m && m < parent } }
+              if hm_models.empty?
+                puts "Missing any real indication as to which models \"has_many\" this polymorphic BT in model #{a.active_record.name}:"
+                puts "  belongs_to :#{a.name}, polymorphic: true"
+              else
+                puts "Having analysed all currently-loaded models to infer the various polymorphic has_many associations for #{model.name}, here are the current results:"
+                puts "::Brick.polymorphics = { \"#{model.table_name}.#{a.name}\" =>
+                         #{hm_models.map(&:name).inspect}
+                       }"
+                puts 'If you add the above to your brick.rb, it will "cement" these options into place, and avoid this lookup process.'
+                s.first[a.foreign_key.to_s] = [a.name, hm_models, true]
+              end
             end
           else
             bt_key = a.foreign_key.is_a?(Array) ? a.foreign_key : a.foreign_key.to_s
@@ -279,7 +299,7 @@ module Brick
         end
       end
       skip_hms.each { |k, _v| hms.delete(k) }
-      [bts, hms]
+      model.instance_variable_set(:@_brick_bts_and_hms, [bts, hms]) # Cache and return this result
     end
 
     def exclude_column(table, col)
@@ -523,6 +543,10 @@ module Brick
       Brick.config.license = key
     end
 
+    def always_load_fields=(field_set)
+      Brick.config.always_load_fields = field_set
+    end
+
     # Load additional references (virtual foreign keys)
     # This is attempted early if a brick initialiser file is found, and then again as a failsafe at the end of our engine's initialisation
     # %%% Maybe look for differences the second time 'round and just add new stuff instead of entirely deferring
@@ -1294,7 +1318,8 @@ ActiveSupport.on_load(:active_record) do
   # rubocop:enable Lint/ConstantDefinitionInBlock
 
   arsc = ::ActiveRecord::StatementCache
-  if is_ruby_2_7 && (params = arsc.method(:create).parameters).length == 2 && params.last == [:opt, :block]
+  if is_ruby_2_7 && arsc.respond_to?(:create) &&
+     (params = arsc.method(:create).parameters).length == 2 && params.last == [:opt, :block]
     arsc.class_exec do
       def self.create(connection, callable = nil, &block)
         relation = (callable || block).call ::ActiveRecord::StatementCache::Params.new
@@ -1387,7 +1412,7 @@ ActiveSupport.on_load(:active_record) do
   # def aliased_table_for(table_name, aliased_name, type_caster)
 
   class ActiveRecord::Associations::JoinDependency
-    if JoinBase.instance_method(:initialize).arity == 2 # Older ActiveRecord <= 5.1?
+    if JoinBase.instance_method(:initialize).arity < 3 # Older ActiveRecord <= 5.1?
       def initialize(base, associations, joins, eager_loading: true)
         araat = ::ActiveRecord::Associations::AliasTracker
         if araat.respond_to?(:create_with_joins) # Rails 5.0 and 5.1
@@ -1395,17 +1420,28 @@ ActiveSupport.on_load(:active_record) do
           cwj_options << base.type_caster if araat.method(:create_with_joins).arity > 3 # Rails <= 5.1
           @alias_tracker = araat.create_with_joins(*cwj_options)
           @eager_loading = eager_loading # (Unused in Rails 5.0)
-        else # Rails 4.2
+        elsif araat.respond_to?(:create) # Rails 4.1 and 4.2
           @alias_tracker = araat.create(base.connection, joins)
           @alias_tracker.aliased_table_for(base, base.table_name) # Updates the count for base.table_name to 1
+        else # Rails 4.0
+          is_rails_4 = true
+          @base_klass    = base
+          @table_joins   = joins
+          @join_parts    = [JoinBase.new(base)]
+          @associations  = {}
+          @reflections   = []
+          @alias_tracker = araat.new(base.connection, joins)
+          @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
+          tree = build(associations)
         end
-        tree = self.class.make_tree associations
+        tree ||= self.class.make_tree associations
 
         # Provide a way to find the original relation that this tree is being used for
         # (so that we can maintain a list of links for all tables used in JOINs)
         if (relation = associations.instance_variable_get(:@relation))
           tree.instance_variable_set(:@relation, relation)
         end
+        return if is_rails_4 # Rails 4.0 doesn't know about the rest
 
         @join_root = JoinBase.new base, build(tree, base)
         @join_root.children.each { |child| construct_tables! @join_root, child }
@@ -1538,6 +1574,21 @@ if ActiveRecord.version < ::Gem::Version.new('5.2')
   end
 end
 
+# By default the awesome_nested_set gem from CollectiveIdea does not prefix the ORDER BY column with its table name.
+# You can see this snag in action in the popular Spree project -- check out the Taxonomy model.  Here is a fix:
+if Gem::Specification.all_names.find { |g| g.start_with?('awesome_nested_set-') }
+  require 'awesome_nested_set/columns'
+  ::CollectiveIdea::Acts::NestedSet::Columns.class_exec do
+    alias _brick_order_column_name order_column_name
+    def order_column_name
+      unless (ord_col = _brick_order_column_name).start_with?(tbl_prefix = "#{table_name}.")
+        ord_col = tbl_prefix << ord_col
+      end
+      ord_col
+    end
+  end
+end
+
 # The "brick_links" patch -- this finds how every AR chain of association names
 # relates back to an exact table correlation name chosen by AREL when the AST tree is
 # walked.  For instance, from a Customer model there could be a join_tree such as
@@ -1567,21 +1618,40 @@ module ActiveRecord
         _brick_build_join_query(manager, buckets, *args) # , **kwargs)
       end
 
-    else
-
+    else # elsif private_instance_methods.include?(:select_association_list)
       alias _brick_select_association_list select_association_list
       def select_association_list(associations, stashed_joins = nil)
         result = _brick_select_association_list(associations, stashed_joins)
         result.instance_variable_set(:@relation, self)
         result
       end
+
+    # else # Rails 4.1 ? and older
+    #   alias _brick_build_joins build_joins
+    #   def build_joins(manager, joins)
+    #     result = _brick_build_joins(manager, joins)
+    #     result.instance_variable_set(:@relation, self)
+    #     result
+    #   end
     end
   end
 
   # require 'active_record/associations/join_dependency'
   module Associations
-    # For AR >= 4.2
-    if self.const_defined?('JoinDependency')
+    if self.const_defined?('JoinHelper') # ActiveRecord < 4.1
+      module JoinHelper
+        alias _brick_construct_tables construct_tables
+        def construct_tables
+          result = _brick_construct_tables
+          # Capture the table alias name that was chosen
+          # if (relation = node.instance_variable_get(:@assocs)&.instance_variable_get(:@relation))
+          #   link_path = node.instance_variable_get(:@link_path)
+          #   relation.brick_links[link_path] = result.first.table_alias || result.first.table_name
+          # end
+          result
+        end
+      end
+    else # For AR >= 4.2
       class JoinDependency
         # An intelligent .eager_load() and .includes() that creates t0_r0 style aliases only for the columns
         # used in .select().  To enable this behaviour, include the flag :_brick_eager_load as the first
@@ -1655,7 +1725,7 @@ module ActiveRecord
             associations.map do |name, right|
               reflection = find_reflection base_klass, name
               reflection.check_validity!
-              reflection.check_eager_loadable!
+              reflection.check_eager_loadable! if reflection.respond_to?(:check_eager_loadable!) # Used in AR >= 4.2
 
               if reflection.polymorphic?
                 raise EagerLoadPolymorphicError.new(reflection)

metadata

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