brick 1.0.138 → 1.0.140

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f044e21a6e4c2120a453b6cb3dc404d4d3e3e15034c638d316cbc418bcb996b
-  data.tar.gz: f3360e5e7778bacde155e58bf0683d6b75c74d7dd63d336131e82b0a1865199a
+  metadata.gz: 995f6ed970029309b465f80193521b91c63335e12400cbb21e0ef0d60fe60dd2
+  data.tar.gz: c610df65f26a9e9bf4f081c8d0172fea6fc69cda350d26cf5287362237e7ceca
 SHA512:
-  metadata.gz: 413c6fe2526752eab0e24998b852e9ae68ef7f56a6488bc14b777e13a4ad281f6c352af465be9e49f05e20fa597e7750d3c706df762f74eb70a18fda5112a319
-  data.tar.gz: cb5040c5333dfa0c0fcbd9d1c04c229e538db1b33fc1526ace987d6da8bd1634e50269e5e05249da6205980ac79c3bad792dd5cc2242115349846365a881bf81
+  metadata.gz: 534bde690d45d11d8371d0e666df86badc47879242bcf67a219aeff6dc71fb1ac668b02bba5059f2fceafa63ddb6312cf3e42e993c5ba1de47ebf276abd9bb7c
+  data.tar.gz: 18e0c976540749fbc93fd89be05735d2e9544db37d04a3738bc06e82fdc2811d9478398fa66881d17e9e18cb44e78720f66cc8db74660ddd6b5e23e523ea2db7

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 || Hash.new { |h, k| h[k] = [] } }
+    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,19 @@ 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
+        ::Brick.config.always_load_fields.fetch(klass.name, nil)&.each do |alf|
+          selects << alf unless selects.include?(alf)
+        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 +634,12 @@ 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}"
+            col_alias = "#{col_prefix}#{k}__#{table_name.tr('.', '_')}_#{cc_part.first}"
           else
             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 +652,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 +822,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 +948,43 @@ 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
 
+    def brick_uniq
+      begin
+        uniq
+      rescue ActiveModel::MissingAttributeError => e
+        # If this model has an #after_initialize then it might try to reference attributes we haven't brought in
+        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_uniq
+          puts "*** WARNING: Missing field!
+  Might want to add this in your brick.rb:
+    ::Brick.always_load_fields = { #{klass.name.inspect} => [#{col_name.inspect}]}"
+          ::Brick.config.always_load_fields[klass.name] << col_name
+          ret
+        else
+          []
+        end
+      end
+    end
+
   private
 
     def shift_or_first(ary)
@@ -935,6 +998,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
@@ -1042,7 +1107,7 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
   end
 end
 
-Module.class_exec do
+::Brick::ADD_CONST_MISSING = lambda do
   alias _brick_const_missing const_missing
   def const_missing(*args)
     requested = args.first.to_s
@@ -1319,7 +1384,14 @@ class Object
       if (base_model = ::Brick.sti_models[full_model_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_model_name]&.constantize)
         is_sti = true
       else
-        base_model = ::Brick.config.models_inherit_from
+        # Class for auto-generated models to inherit from
+        base_model = (::Brick.config.models_inherit_from ||= (app.config.brick.fetch(:models_inherit_from, nil) ||
+                                                              begin
+                                                                ::ApplicationRecord
+                                                              rescue StandardError => ex
+                                                                ::ActiveRecord::Base
+                                                              end))
+
       end
       hmts = nil
       code = +"class #{full_name} < #{base_model.name}\n"
@@ -1486,8 +1558,10 @@ class Object
                                assoc[:assoc_name]
                              end
                 options[:optional] = true if assoc.key?(:optional)
-                if assoc.key?(:polymorphic)
-                  options[:polymorphic] = true
+                if assoc.key?(:polymorphic) ||
+                   # If a polymorphic association is missing but could be established then go ahead and put it into place.
+                   relations[assoc[:inverse_table]][:class_name].constantize.reflect_on_all_associations.find { |inv_assoc| !inv_assoc.belongs_to? && inv_assoc.options[:as].to_s == assoc[:assoc_name] }
+                  assoc[:polymorphic] ||= (options[:polymorphic] = true)
                 else
                   need_class_name = singular_table_name.underscore != assoc_name
                   need_fk = "#{assoc_name}_id" != assoc[:fk]
@@ -1548,7 +1622,11 @@ class Object
                                   assoc[:fk].to_sym
                                 end
       end
-      options[:inverse_of] = inverse_assoc_name.tr('.', '_').to_sym if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of)
+      if inverse_assoc_name && (need_class_name || need_fk || need_inverse_of) &&
+         (klass = options[:class_name]&.constantize) && (ian = inverse_assoc_name.tr('.', '_').to_sym) &&
+         (klass.is_brick? || klass.reflect_on_association(ian))
+        options[:inverse_of] = ian
+      end
 
       # Prepare a list of entries for "has_many :through"
       if macro == :has_many
@@ -1591,14 +1669,38 @@ class Object
       built_controller = Class.new(controller_base || ActionController::Base) do |new_controller_class|
         (namespace || Object).const_set(class_name.to_sym, new_controller_class)
 
+        # 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 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)
+                  request.env[nonce] = '' # Generally 'action_dispatch.content_security_policy_nonce'
+                end
+                # Keep only self, if present, and also add this value
+                cspd.select! { |val| val == "'self'" }
+                cspd << style_value
+              else
+                cspd << "'sha256-QHKxqKcUq7AER1QwEu5uQXRQwC8j4iTWkE8mpOmP7ms='"
+              end
+              cspd << 'https://cdn.jsdelivr.net'
+            end
+            if (cspd = csp.directives.fetch('script-src'))
+              cspd << 'https://cdn.jsdelivr.net'
+            end
+          end
+        end
+
         # Brick-specific pages
         case plural_class_name
         when 'BrickGem'
           self.define_method :status do
             instance_variable_set(:@resources, ::Brick.get_status_of_resources)
+            add_csp_hash
           end
           self.define_method :orphans do
             instance_variable_set(:@orphans, ::Brick.find_orphans(::Brick.set_db_schema(params).first))
+            add_csp_hash
           end
           self.define_method :crosstab do
             @relations = ::Brick.relations.each_with_object({}) do |r, s|
@@ -1813,9 +1915,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
@@ -1881,6 +1983,7 @@ class Object
             @_brick_hm_counts = real_model._br_hm_counts
             @_brick_join_array = join_array
             @_brick_erd = params['_brick_erd']&.to_i
+            add_csp_hash
           end
         end
 
@@ -1911,6 +2014,7 @@ class Object
             self.define_method :show do
               _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
               instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+              add_csp_hash("'unsafe-inline'")
             end
           end
 
@@ -1928,6 +2032,7 @@ class Object
               end if Object.const_defined?('ActiveStorage')
             end
             instance_variable_set("@#{singular_table_name}".to_sym, new_obj)
+            add_csp_hash
           end
 
           params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
@@ -1968,6 +2073,7 @@ class Object
             self.define_method :edit do
               _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
               instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+              add_csp_hash
             end
 
             code << "  def update\n"

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

@@ -209,10 +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|
+        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)
@@ -598,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
 
@@ -678,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
 
@@ -736,11 +743,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                     end
                   when 'show', 'new', 'update'
                     hm_stuff << if hm_fk_name
-                                  if hm_assoc.klass.column_names.include?(hm_fk_name) ||
+                                  if hm_assoc.klass.column_names.include?(hm_fk_name.to_s) ||
                                      (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
@@ -798,6 +805,10 @@ window.addEventListener(\"popstate\", linkSchemas);
   left: 0;
 }
 
+.flashNotice {
+  color: green;
+}
+
 h1, h3 {
   margin-bottom: 0;
 }
@@ -1313,7 +1324,7 @@ erDiagram
 </head>
 <body>
 <div id=\"titleBox\"><div id=\"titleSticky\">
-<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
+<p class=\"flashNotice\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><tr>
@@ -1453,11 +1464,11 @@ end
 # Must load all models, and then find what table names are represented
 # Easily could be multiple files involved (STI for instance)
 +"#{css}
-<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
+<p class=\"flashNotice\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{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>
@@ -1476,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
@@ -1503,7 +1518,7 @@ end
                        when 'orphans'
                          if is_orphans
 +"#{css}
-<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
+<p class=\"flashNotice\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <h1>Orphans<%= \" for #\{}\" if false %></h1>
@@ -1536,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>
@@ -1550,7 +1567,7 @@ end
   c23.141-70.188,89.141-120.906,167.063-120.906c97.25,0,176,78.813,176,176C511.828,227.078,404.391,119.641,271.844,119.641z\" />
 </svg>
 
-<p style=\"color: green\"><%= notice if request.respond_to?(:flash) %></p>#{"
+<p class=\"flashNotice\"><%= notice if request.respond_to?(:flash) %></p>#{"
 #{schema_options}" if schema_options}
 <select id=\"tbl\">#{table_options}</select>
 <table id=\"resourceName\"><td><h1><%= page_title %></h1></td>
@@ -1631,7 +1648,7 @@ 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, descrip_cols = bt_class&.order(Arel.sql(\"#\{bt_class.table_name}.#\{obj_pk = bt_class.primary_key}\"))&.brick_list
           collection&.each do |obj|
             option_detail << [
               obj.brick_descrip(
@@ -1712,15 +1729,22 @@ 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 |#{hm_singular_name}| %>
-            <tr><td><%= br_descrip = #{hm_singular_name}.brick_descrip(
-                                       descrip_cols&.first&.map { |col| #{hm_singular_name}.send(col.last) }
-                                     )
-                        link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
+          collection2.each do |br_#{hm_singular_name}| %>
+            <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 %>
       </table>"

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 138
+    TINY = 140
 
     # 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
@@ -254,7 +274,7 @@ module Brick
               next
             end
           else
-            if !a.options.key?(:as) && a.klass.column_names.exclude?(a.foreign_key)
+            if !a.options.key?(:as) && a.klass.column_names.exclude?(a.foreign_key.to_s)
               options = ", #{a.options.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}" if a.options.present?
               puts "WARNING:  Model #{model.name} has this association:
             has_many :#{a.name}#{options}
@@ -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
@@ -922,11 +946,19 @@ In config/initializers/brick.rb appropriate entries would look something like:
           end
         end
 
-        if ::Brick.config.add_status && instance_variable_get(:@set).named_routes.names.exclude?(:brick_status)
-          get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: 'brick_status')
+        if ::Brick.config.add_status && (status_as = "#{controller_prefix.tr('/', '_')}brick_status".to_sym)
+           (
+             !(status_route = instance_variable_get(:@set).named_routes.find { |route| route.first == status_as }&.last) ||
+             !status_route.ast.to_s.include?("/#{controller_prefix}brick_status/")
+           )
+          get("/#{controller_prefix}brick_status", to: 'brick_gem#status', as: status_as.to_s)
         end
 
-        if ::Brick.config.add_orphans && instance_variable_get(:@set).named_routes.names.exclude?(:brick_orphans)
+        if ::Brick.config.add_orphans && (orphans_as = "#{controller_prefix.tr('/', '_')}brick_orphans".to_sym)
+           (
+             !(orphans_route = instance_variable_get(:@set).named_routes.find { |route| route.first == orphans_as }&.last) ||
+             !orphans_route.ast.to_s.include?("/#{controller_prefix}brick_orphans/")
+           )
           get("/#{controller_prefix}brick_orphans", to: 'brick_gem#orphans', as: 'brick_orphans')
         end
 
@@ -1286,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
@@ -1379,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
@@ -1387,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 }
@@ -1530,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
@@ -1559,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
@@ -1647,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.138
+  version: 1.0.140
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-06 00:00:00.000000000 Z
+date: 2023-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord