brick 1.0.122 → 1.0.124

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1f047f700bc850e0e54210cd9669e2877c2d770010f42c82b7f2616ad14f542
-  data.tar.gz: e89b2be75f7d961b24681b4e6c5aeb8beedef51e2537759f93a68baff1787e60
+  metadata.gz: 44fce70a53b4467d019ca42a9826f44a4849d472dcbfc2fe324f961708b70a18
+  data.tar.gz: 2674709f203786560b41c1bf1e2062336cf88282d168848303e9920b398662e3
 SHA512:
-  metadata.gz: 54418f3b20260bea82b912383038fce3a019a6daf85e56714a1eb2331c7aa130c44706d64e8d1c86502d9ed7c6f7ece730b8a3d467fbe77ee3e699f8e2eb1586
-  data.tar.gz: baf068daf69952fd2235b14abddd93420b73984912eef5da6ffc33699db124058b2e6a093d9984d2fe31abbe620e6d51d5bdbecc5cf23297f6c31b4d4450ed71
+  metadata.gz: 337760a0382fd37a64026a07d80e708f9f475f73e8ca420d05341b731c977ab9153556803f10314a4851730e28a22ce4847705e2d8ad81121a8f33736f505f12
+  data.tar.gz: 04a1e5ec1cc503173da16be708d611f9fb1dd6f3965e6e848dfd1e310f3e1c94b396c8e693982d8f3c3589b5d8ffbfee70fd52593918e12ecd8309c8e110b4c5

data/lib/brick/extensions.rb

@@ -638,6 +638,7 @@ module ActiveRecord
       # Add derived table JOIN for the has_many counts
       nix = []
       klass._br_hm_counts.each do |k, hm|
+        num_bt_things = 0
         count_column = if hm.options[:through]
                          # Build the chain of JOINs going to the final destination HMT table
                          # (Usually just one JOIN, but could be many.)
@@ -668,6 +669,8 @@ module ActiveRecord
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             link_back << nm
+                                            num_bt_things += 1
+                                            # puts "BT #{a.table_name}"
                                             "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
                                           elsif src_ref.options[:as]
                                             "ON br_t#{idx}.#{src_ref.type} = '#{src_ref.active_record.name}'" + # "polymorphable_type"
@@ -686,6 +689,7 @@ module ActiveRecord
                                                 "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.id"
                                             end
                                           else # Standard has_many or has_one
+                                            # puts "HM #{a.table_name}"
                                             # binding.pry unless (
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             # )
@@ -708,7 +712,13 @@ module ActiveRecord
                            # binding.pry if link_back.length > 2
                            "br_t#{idx}.#{hm.foreign_key}"
                          else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
-                           # binding.pry if link_back.length > 2
+                           # %%% Currently flaky, so will revisit this soon, probably while implementing the whole link_back architecture
+                           if num_bt_things > 1
+                             # binding.pry
+                             nix << k
+                             next
+                           end
+
                            "br_t#{idx}.#{src_ref.active_record.primary_key}"
                          end
                        else
@@ -1859,18 +1869,27 @@ class Object
               instance_variable_set("@#{singular_table_name}".to_sym, (obj = find_obj))
               upd_params = send(params_name_sym)
               json_overrides = ::Brick.config.json_columns&.fetch(table_name, nil)
-              if (json_cols = model.columns.select { |c| c.type == :json || json_overrides&.include?(c.name) }.map(&:name)).present?
+              if model.respond_to?(:devise_modules)
                 upd_hash = upd_params.to_h
+                upd_hash['reset_password_token'] = nil if upd_hash['reset_password_token'].blank?
+                upd_hash['reset_password_sent_at'] = nil if upd_hash['reset_password_sent_at'].blank?
+                if model.devise_modules.include?(:invitable)
+                  upd_hash['invitation_token'] = nil if upd_hash['invitation_token'].blank?
+                  upd_hash['invitation_created_at'] = nil if upd_hash['invitation_created_at'].blank?
+                  upd_hash['invitation_sent_at'] = nil if upd_hash['invitation_sent_at'].blank?
+                  upd_hash['invitation_accepted_at'] = nil if upd_hash['invitation_accepted_at'].blank?
+                end
+              end
+              if (json_cols = model.columns.select { |c| c.type == :json || json_overrides&.include?(c.name) }.map(&:name)).present?
+                upd_hash ||= upd_params.to_h
                 json_cols.each do |c|
                   begin
                     upd_hash[c] = JSON.parse(upd_hash[c].tr('`', '"').gsub('^^br_btick__', '`'))
                   rescue
                   end
                 end
-                obj.send(:update, upd_hash)
-              else
-                obj.send(:update, upd_params)
               end
+              obj.send(:update, upd_hash || upd_params)
             end
 
             code << "  def destroy\n"
@@ -1906,10 +1925,11 @@ class Object
                      end
                    end
               # Support friendly_id gem
+              id_simplified = id.is_a?(Array) && id.length == 1 ? id.first : id
               if Object.const_defined?('FriendlyId') && model.instance_variable_get(:@friendly_id_config)
-                model.friendly.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+                model.friendly.find(id_simplified)
               else
-                model.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
+                model.find(id_simplified)
               end
             end
           end
@@ -2044,8 +2064,18 @@ end.class_exec do
         load inflections
       end
       # Now the Brick initializer since there may be important schema things configured
-      if File.exist?(brick_initializer = ::Rails.root.join('config/initializers/brick.rb'))
+      if !::Brick.initializer_loaded && File.exist?(brick_initializer = ::Rails.root.join('config/initializers/brick.rb'))
         ::Brick.initializer_loaded = load brick_initializer
+
+        # After loading the initializer, add compatibility for ActiveStorage and ActionText if those haven't already been
+        # defined.  (Further JSON configuration for ActiveStorage metadata happens later in the after_initialize hook.)
+        ['ActiveStorage', 'ActionText'].each do |ar_extension|
+          if Object.const_defined?(ar_extension) &&
+             (extension = Object.const_get(ar_extension)).respond_to?(:table_name_prefix) &&
+             !::Brick.config.table_name_prefixes.key?(as_tnp = extension.table_name_prefix)
+            ::Brick.config.table_name_prefixes[as_tnp] = ar_extension
+          end
+        end
       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
@@ -2478,9 +2508,9 @@ module Brick
   # rubocop:enable Style/CommentedKeyword
 
   class << self
-    def _add_bt_and_hm(fk, relations, is_polymorphic = false, is_optional = false)
+    def _add_bt_and_hm(fk, relations, polymorphic_class = nil, is_optional = false)
       bt_assoc_name = ::Brick.namify(fk[2], :downcase)
-      unless is_polymorphic
+      unless polymorphic_class
         bt_assoc_name = if bt_assoc_name.underscore.end_with?('_id')
                           bt_assoc_name[-3] == '_' ? bt_assoc_name[0..-4] : bt_assoc_name[0..-3]
                         elsif bt_assoc_name.downcase.end_with?('id') && bt_assoc_name.exclude?('_')
@@ -2535,7 +2565,7 @@ module Brick
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
           return
         end
-        unless (cols = relations[fk[1]][:cols]).key?(fk[2]) || (is_polymorphic && cols.key?("#{fk[2]}_id") && cols.key?("#{fk[2]}_type"))
+        unless (cols = relations[fk[1]][:cols]).key?(fk[2]) || (polymorphic_class && cols.key?("#{fk[2]}_id") && cols.key?("#{fk[2]}_type"))
           columns = cols.map { |k, v| "#{k} (#{v.first.split(' ').first})" }
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[2]}. (Columns present in #{fk[1]} are #{columns.join(', ')}.)"
           return
@@ -2552,9 +2582,10 @@ module Brick
       return unless bts # Rails 5.0 and older can have bts end up being nil
 
       if (assoc_bt = bts[cnstr_name])
-        if is_polymorphic
+        if polymorphic_class
           # Assuming same fk (don't yet support composite keys for polymorphics)
           assoc_bt[:inverse_table] << fk[4]
+          assoc_bt[:polymorphic] << polymorphic_class
         else # Expect we could have a composite key going
           if assoc_bt[:fk].is_a?(String)
             assoc_bt[:fk] = [assoc_bt[:fk], fk[2]] unless fk[2] == assoc_bt[:fk]
@@ -2564,10 +2595,10 @@ module Brick
           assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[2]}"
         end
       else
-        inverse_table = [primary_table] if is_polymorphic
+        inverse_table = [primary_table] if polymorphic_class
         assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[2], assoc_name: bt_assoc_name, inverse_table: inverse_table || primary_table }
         assoc_bt[:optional] = true if is_optional
-        assoc_bt[:polymorphic] = true if is_polymorphic
+        assoc_bt[:polymorphic] = [polymorphic_class] if polymorphic_class
       end
       if is_class
         # For use in finding the proper :source for a HMT association that references an STI subclass
@@ -2593,7 +2624,7 @@ module Brick
                   end
         assoc_hm = hms[hm_cnstr_name] = { is_bt: false, fk: fk[2], assoc_name: fk_namified.pluralize, alternate_name: bt_assoc_name,
                                           inverse_table: inv_tbl, inverse: assoc_bt }
-        assoc_hm[:polymorphic] = true if is_polymorphic
+        assoc_hm[:polymorphic] = true if polymorphic_class
         hm_counts = relation.fetch(:hm_counts) { relation[:hm_counts] = {} }
         this_hm_count = hm_counts[fk[1]] = hm_counts.fetch(fk[1]) { 0 } + 1
       end

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

@@ -188,6 +188,17 @@ function linkSchemas() {
           (app.config.assets.paths ||= []) << assets_path
         end
 
+        # Treat ActiveStorage::Blob metadata as JSON
+        if ::Brick.config.table_name_prefixes.fetch('active_storage_', nil) == 'ActiveStorage' &&
+           ActiveStorage.const_defined?('Blob')
+          unless (md = (::Brick.config.model_descrips ||= {})).key?('ActiveStorage::Blob')
+            md['ActiveStorage::Blob'] = '[filename]'
+          end
+          unless (asbm = (::Brick.config.json_columns['active_storage_blobs'] ||= [])).include?('metadata')
+            asbm << 'metadata'
+          end
+        end
+
         # Smarten up Avo so it recognises Brick's querystring option for Apartment multi-tenancy
         if Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace)
           module ::Avo
@@ -586,7 +597,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                     return possible_template
                   end
                 rescue StandardError => e
-                  find_template_err = e # Can come up with stuff like Devise which has its own view templates
+                  # 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] }
+
+                  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
@@ -646,7 +661,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}"
+                                                     "'#{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
@@ -1551,8 +1566,12 @@ end
 <head>
 #{css}
 <title><%=
-  model = (obj = @#{obj_name})&.class
-  model_name = @#{obj_name}.#{inh_col = @_brick_model.inheritance_column} if obj.respond_to?(:#{inh_col})
+  base_model = (model = (obj = @#{obj_name})&.class).base_class
+  see_all_path = send(\"#\{base_model._brick_index}_path\")
+  if obj.respond_to?(:#{inh_col = @_brick_model.inheritance_column}) &&
+     (model_name = @#{obj_name}.#{inh_col}) != base_model.name
+    see_all_path << \"?#{inh_col}=#\{model_name}\"
+  end
   page_title = (\"#\{model_name ||= model.name}: #\{obj&.brick_descrip || controller_name}\")
 %></title>
 </head>
@@ -1596,7 +1615,7 @@ end
 if (description = (relation = Brick.relations[tbl_name = #{model_name}.table_name])&.fetch(:description, nil)) %><%=
   description %><br><%
 end
-%><%= link_to '(See all #{obj_name.pluralize})', #{@_brick_model._brick_index}_path %>
+%><%= link_to \"(See all #\{model_name.pluralize})\", see_all_path %>
 #{erd_markup}
 <% if obj
       # path_options = [obj.#{pk}]
@@ -1612,11 +1631,11 @@ end
 <%= form_for(obj.becomes(#{model_name}), options) do |f| %>
   <table class=\"shadow\">
   <% has_fields = false
-    @#{obj_name}.attributes.each do |k, val|
-      col = #{model_name}.columns_hash[k] %>
-    <tr>
-    <% next if (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
+     @#{obj_name}.attributes.each do |k, val|
+       next if !(col = #{model_name}.columns_hash[k]) ||
+               (#{(pk || []).inspect}.include?(k) && !bts.key?(k)) ||
                ::Brick.config.metadata_columns.include?(k) %>
+    <tr>
     <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
     <% has_fields = true
       if (bt = bts[k])
@@ -1680,9 +1699,13 @@ end
            if is_bcrypt?(val) # || .readonly?
              is_revert = false %>
           <%= hide_bcrypt(val, nil, 1000) %>
-        <% elsif col_type == :string %>
-          <%= f.text_field(k.to_sym, html_options) %>
-        <% else
+        <% elsif col_type == :string
+             if model.respond_to?(:enumerized_attributes) && (opts = model.enumerized_attributes[k]&.options).present? %>
+               <%= f.select(k.to_sym, [[\"(No #\{k} chosen)\", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, html_options) %><%
+             else %>
+               <%= f.text_field(k.to_sym, html_options) %><%
+             end
+           else
              is_includes_text = true %>
           <%= f.hidden_field(k.to_sym, html_options) %>
           <trix-editor input=\"<%= f.field_id(k) %>\"></trix-editor>

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

@@ -170,11 +170,8 @@ module Brick::Rails::FormTags
                        if klass
                          type_col = klass.inheritance_column # Usually 'type'
                          filter_parts << "#{type_col}=#{sti_type}" if sti_type && klass.column_names.include?(type_col)
-                         path_params = request.path_parameters.dup
-                         path_params.delete(:controller)
-                         path_params.delete(:action)
+                         path_params = request.path_parameters
                          pk = (klass.primary_key || ActiveRecord::Base.primary_key).to_sym
-                         # Used to also have this but it's a bit too permissive to identify a primary key:  (path_params.length == 1 && path_params.values.first) ||
                          if ((id = (path_params[pk] || path_params[:id] || path_params["#{klass.name.underscore}_id".to_sym])) && (obj = klass.find_by(pk => id))) ||
                             (['show', 'edit', 'update', 'destroy'].include?(action_name) && (obj = klass.first))
                            obj
@@ -183,7 +180,18 @@ module Brick::Rails::FormTags
                            # %%% If there is a polymorphic association that might relate to stuff in the path_params,
                            # try to identify an appropriate ___able_id and ___able_type filter
                            ((klass.column_names - [pk.to_s]) & path_params.keys.map(&:to_s)).each do |path_param|
-                             filter_parts << "#{path_param}=#{path_params[path_param.to_sym]}"
+                             next if [:controller, :action].include?(path_param)
+
+                             foreign_id = path_params[path_param.to_sym]
+                             # Need to convert a friendly_id slug to a real ID?
+                             if Object.const_defined?('FriendlyId') &&
+                                (assoc = klass.reflect_on_all_associations.find { |a| a.belongs_to? && a.foreign_key == path_param }) &&
+                                (assoc_klass = assoc.klass).instance_variable_get(:@friendly_id_config) &&
+                                (new_id = assoc_klass.where(assoc_klass.friendly_id_config.query_field => foreign_id)
+                                                     .pluck(assoc_klass.primary_key).first)
+                               foreign_id = new_id
+                             end
+                             filter_parts << "#{path_param}=#{foreign_id}"
                            end
                            klass
                          end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -208,7 +208,7 @@ module Brick
           if a.polymorphic?
             rel_poly_bt = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s }
             if (primary_tables = rel_poly_bt&.last&.fetch(:inverse_table, [])).is_a?(Array)
-              models = primary_tables&.map { |table| table.singularize.camelize.constantize }
+              models = rel_poly_bt[1][:polymorphic]&.map { |table| table.singularize.camelize.constantize }
               s.first[a.foreign_key.to_s] = [a.name, models, true]
             else
               # This will come up when using Devise invitable when invited_by_class_name is not
@@ -523,8 +523,13 @@ module Brick
             table_name, poly = k.split('.')
             v ||= ActiveRecord::Base.execute_sql("SELECT DISTINCT #{poly}_type AS typ FROM #{table_name}").each_with_object([]) { |result, s| s << result['typ'] if result['typ'] }
             v.each do |type|
-              if relations.key?(primary_table = type.underscore.pluralize)
-                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations, true, is_optional)
+              # Allow polymorphic BT to relate to an STI subclass
+              base_type = ::Brick.config.sti_namespace_prefixes["::#{type}"] ||
+                          ::Brick.config.sti_namespace_prefixes.find { |k, _v| type.start_with?(k[2..-1]) }&.last&.[](2..-1)
+              if relations.key?(primary_table = (base_type || type).underscore.pluralize)
+                ::Brick._add_bt_and_hm([nil, table_name, poly, nil, primary_table, "(brick) #{table_name}_#{poly}"], relations,
+                                       type, # Polymorphic class
+                                       is_optional)
               else
                 missing_stis[primary_table] = type unless ::Brick.existing_stis.key?(type)
               end
@@ -1694,6 +1699,29 @@ if Gem::Specification.all_names.any? { |g| g.start_with?('ransack-') }
   end
 end
 
+# Patch Enumerize so that #becomes works when an STI subclass is becoming a base class
+# which does not include Enumerize.
+# (See https://github.com/brainspec/enumerize/issues/426)
+if Object.const_defined?('Enumerize') && Enumerize.const_defined?('ActiveRecordSupport')
+  Enumerize::ActiveRecordSupport::InstanceMethods.class_exec do
+    def becomes(klass)
+      became = super
+      klass = self.class unless klass.respond_to?(:enumerized_attributes)
+      klass.enumerized_attributes.each do |attr|
+        begin
+          if became.respond_to?(setter = "#{attr.name}=")
+            became.send(setter, send(attr.name))
+          end
+        rescue ActiveModel::MissingAttributeError
+        rescue ActiveRecord::SerializationTypeMismatch
+          became.send(setter, send(attr.name).to_ary)
+        end
+      end
+      became
+    end
+  end
+end
+
 # Keyword arguments updates for Rails <= 5.2.x and Ruby >= 3.0
 if ActiveRecord.version < ::Gem::Version.new('6.0') && ruby_version >= ::Gem::Version.new('3.0')
   admsm = ActionDispatch::MiddlewareStack::Middleware

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.122
+  version: 1.0.124
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-23 00:00:00.000000000 Z
+date: 2023-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord