brick 1.0.124 → 1.0.125

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44fce70a53b4467d019ca42a9826f44a4849d472dcbfc2fe324f961708b70a18
-  data.tar.gz: 2674709f203786560b41c1bf1e2062336cf88282d168848303e9920b398662e3
+  metadata.gz: dc3caefac264427d0a4a7efa11160fc3b7c1cc6c82afa01bf7340941dbab18e1
+  data.tar.gz: 7d9aebd13fe256d43ee3ec24f94065a64ab4955e3ee379023352013db59fe3ba
 SHA512:
-  metadata.gz: 337760a0382fd37a64026a07d80e708f9f475f73e8ca420d05341b731c977ab9153556803f10314a4851730e28a22ce4847705e2d8ad81121a8f33736f505f12
-  data.tar.gz: 04a1e5ec1cc503173da16be708d611f9fb1dd6f3965e6e848dfd1e310f3e1c94b396c8e693982d8f3c3589b5d8ffbfee70fd52593918e12ecd8309c8e110b4c5
+  metadata.gz: c02e8bdceca8f726d24a8f7eddb6057427d2e31c3db3934bd72da0393509aaf2d5e7246ba65e8bdd773fc3d995c538567137dec729eb2d062ba0f7e006ace7c6
+  data.tar.gz: c6061b00b761638ebd0f9750423643615c08dffb9c62bec423d1bf5c047dcfa82c9b2bccaea1491d9f7a4c23932b9299be1254e708e26ca624165a5695557c63

data/lib/brick/extensions.rb

@@ -68,6 +68,12 @@ module ActiveRecord
           self
         end
       end
+
+      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) &&
+         (attr_types.coder.is_a?(Class) ? attr_types.coder : attr_types.coder&.class)&.name&.end_with?('JSON'))
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -671,7 +677,7 @@ module ActiveRecord
                                             link_back << nm
                                             num_bt_things += 1
                                             # puts "BT #{a.table_name}"
-                                            "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
+                                            "ON br_t#{idx}.#{a.active_record.primary_key} = 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"
                                             " AND br_t#{idx}.#{src_ref.foreign_key} = br_t#{idx - 1}.id"
@@ -682,11 +688,11 @@ module ActiveRecord
                                               bail_out = true
                                               break
                                               # "ON br_t#{idx}.#{a.foreign_type} = '#{src_ref.options[:source_type]}' AND " \
-                                              #   "br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
+                                              #   "br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.#{a.active_record.primary_key}"
                                             else # Works for HMT through a polymorphic HO
                                               link_back << hmt_assoc.source_reflection.inverse_of&.name # Some polymorphic "_able" thing
                                               "ON br_t#{idx - 1}.#{a.foreign_type} = '#{src_ref.options[:source_type]}' AND " \
-                                                "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.id"
+                                                "br_t#{idx - 1}.#{a.foreign_key} = br_t#{idx}.#{a.active_record.primary_key}"
                                             end
                                           else # Standard has_many or has_one
                                             # puts "HM #{a.table_name}"
@@ -694,7 +700,7 @@ module ActiveRecord
                                             nm = hmt_assoc.source_reflection.inverse_of&.name
                                             # )
                                             link_back << nm # if nm
-                                            "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
+                                            "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.#{a.active_record.primary_key}"
                                           end
                            link_back.unshift(a.source_reflection.name)
                            [a.table_name, a.foreign_key, a.source_reflection.macro]
@@ -856,8 +862,7 @@ 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)
         if ::Brick.sti_models.key?(type_name ||= name)
-          # Used to be:  ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
-          _brick_find_sti_class(type_name)
+          ::Brick.sti_models[type_name].fetch(:base, nil) || _brick_find_sti_class(type_name)
         else
           # This auto-STI is more of a brute-force approach, building modules where needed
           # The more graceful alternative is the overload of ActiveSupport::Dependencies#autoload_module! found below
@@ -865,9 +870,13 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
           module_prefixes = type_name.split('::')
           module_prefixes.unshift('') unless module_prefixes.first.blank?
           module_name = module_prefixes[0..-2].join('::')
-          if (snp = ::Brick.config.sti_namespace_prefixes)&.key?("::#{module_name}::") || snp&.key?("#{module_name}::") ||
+          if (base_name = ::Brick.config.sti_namespace_prefixes&.fetch("#{module_name}::", nil)) ||
              File.exist?(candidate_file = ::Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
-            _brick_find_sti_class(type_name) # Find this STI class normally
+            if base_name
+              base_name == "::#{name}" ? self : base_name.constantize
+            else
+              _brick_find_sti_class(type_name) # Find this STI class normally
+            end
           else
             # Build missing prefix modules if they don't yet exist
             this_module = Object
@@ -988,6 +997,8 @@ Module.class_exec do
                     end
                     Object
                   else
+                    sti_base = (::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::#{requested}", nil) ||
+                                ::Brick.config.sti_namespace_prefixes&.fetch("::#{name}::", nil))&.constantize
                     self
                   end
     # puts "#{self.name} - #{args.first}"
@@ -995,7 +1006,7 @@ Module.class_exec do
     if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) &&
         # Reset `possible` if it's a controller request that's not a perfect match
         # Was:  (possible = nil)  but changed to #local_variable_set in order to suppress the "= should be ==" warning
-        (possible.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
+        (possible&.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
        # Try to require the respective Ruby file
        ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
                     (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
@@ -1005,9 +1016,11 @@ Module.class_exec do
        # If any class has turned up so far (and we're not in the middle of eager loading)
        # then return what we've found.
        (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
-      if (!brick_root && (filename || possible.instance_of?(Class))) ||
-         (possible.instance_of?(Module) && possible&.module_parent == self) ||
-         (possible.instance_of?(Class) && possible == self) # Are we simply searching for ourselves?
+      if ((!brick_root && (filename || possible.instance_of?(Class))) ||
+          (possible.instance_of?(Module) && possible&.module_parent == self) ||
+          (possible.instance_of?(Class) && possible == self)) && # Are we simply searching for ourselves?
+         # Skip when what we found as `possible` is not related to the base class of an STI model
+         (!sti_base || possible.is_a?(sti_base))
         return possible
       end
     end
@@ -1139,7 +1152,8 @@ class Object
 
     def build_model(relations, base_module, base_name, class_name, inheritable_name = nil)
       tnp = ::Brick.config.table_name_prefixes&.find { |p| p.last == base_module.name }&.first
-      if (base_model = ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil)&.constantize) || # Are we part of an auto-STI namespace? ...
+      if (base_model = (::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::#{class_name}", nil) || # Are we part of an auto-STI namespace? ...
+                        ::Brick.config.sti_namespace_prefixes&.fetch("::#{base_module.name}::", nil))&.constantize) ||
          base_module != Object # ... or otherwise already in some namespace?
         schema_name = [(singular_schema_name = base_name.underscore),
                        (schema_name = singular_schema_name.pluralize),
@@ -1151,7 +1165,6 @@ class Object
       singular_table_name = ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
 
       if base_model
-        schema_name = base_name.underscore # For the auto-STI namespace models
         table_name = base_model.table_name
         build_model_worker(base_module, inheritable_name, model_name, singular_table_name, table_name, relations, table_name)
       else
@@ -1181,7 +1194,7 @@ class Object
       full_name = if relation || schema_name.blank?
                     inheritable_name || model_name
                   else # Prefix the schema to the table name + prefix the schema namespace to the class name
-                    schema_module = if schema_name.instance_of?(Module) # from an auto-STI namespace?
+                    schema_module = if schema_name.is_a?(Module) # from an auto-STI namespace?
                                       schema_name
                                     else
                                       matching = "#{schema_name}.#{matching}"
@@ -1880,7 +1893,7 @@ class Object
                   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?
+              if (json_cols = model.columns.select { |c| model.json_column?(c) }.map(&:name)).present?
                 upd_hash ||= upd_params.to_h
                 json_cols.each do |c|
                   begin
@@ -2682,11 +2695,13 @@ module Brick
                    end
                  end
                end
-      ::Brick.relations.keys.map do |v|
-        tbl_parts = v.split('.')
+      ::Brick.relations.map do |k, v|
+        tbl_parts = k.split('.')
         tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
         res = tbl_parts.join('.')
-        [v, (model = models[res])&.last&.table_name, migrations&.fetch(res, nil), model&.first]
+        [k, (model = models[res])&.last&.table_name || v[:class_name].constantize.table_name,
+            migrations&.fetch(res, nil),
+            model&.first]
       end
     end
 

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

@@ -1245,6 +1245,7 @@ erDiagram
   }
 <% end
  # callback < %= cb_k % > erdClick
+ @_brick_monetized_attributes = model.respond_to?(:monetized_attributes) ? model.monetized_attributes.values : {}
  %>
 </div>
 "
@@ -1612,7 +1613,7 @@ end
    end %>
 </table>
 <%
-if (description = (relation = Brick.relations[tbl_name = #{model_name}.table_name])&.fetch(:description, nil)) %><%=
+if (description = (relation = Brick.relations[#{model_name}.table_name])&.fetch(:description, nil)) %><%=
   description %><br><%
 end
 %><%= link_to \"(See all #\{model_name.pluralize})\", see_all_path %>
@@ -1686,22 +1687,25 @@ end
          elsif val
            \"<span class=\\\"orphan\\\">Orphaned ID: #\{val}</span>\".html_safe
          end %>
-    <% else
-         col_type = if ::Brick.config.json_columns[tbl_name]&.include?(k)
-                     :json
-                   elsif col&.sql_type == 'geography'
-                     col.sql_type
-                   else
-                     col&.type
-                   end
+    <% elsif @_brick_monetized_attributes&.include?(k)
+    %><%= f.text_field(k.to_sym, html_options.merge({ value: Money.new(val.to_i).format })) %><%
+       else
+         col_type = if model.json_column?(col)
+                      :json
+                    elsif col&.sql_type == 'geography'
+                      col.sql_type
+                    else
+                      col&.type
+                    end
          case (col_type ||= col&.sql_type)
          when :string, :text
            if is_bcrypt?(val) # || .readonly?
              is_revert = false %>
           <%= hide_bcrypt(val, nil, 1000) %>
         <% 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) %><%
+             if model.respond_to?(:enumerized_attributes) && (attr = model.enumerized_attributes[k])&.options.present?
+               enum_html_options = attr.kind_of?(Enumerize::Multiple) ? html_options.merge({ multiple: true, size: (opts = attr.options)&.length + 1 }) : html_options %>
+               <%= f.select(k.to_sym, [[\"(No #\{k} chosen)\", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, enum_html_options) %><%
              else %>
                <%= f.text_field(k.to_sym, html_options) %><%
              end

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

@@ -20,40 +20,50 @@ module Brick::Rails::FormTags
       s << col_name
       cols[col_name] = col
     end
+    composite_bts = bts.select { |k, _v| k.is_a?(Array) }
+    composite_bt_names = {}
+    composite_bt_cols = composite_bts.each_with_object([]) do |bt, s|
+      composite_bt_names[bt.first.join('__')] = bt.last
+      bt.first.each { |bt_col| s << bt_col unless s.include?(bt_col.first) }
+    end
     unless sequence # If no sequence is defined, start with all inclusions
       cust_cols = klass._br_cust_cols
       # HOT columns, kept as symbols
       hots = klass._br_bt_descrip.keys.select { |k| bts.key?(k) }
-      sequence = col_keys + cust_cols.keys + hots + hms_keys.reject { |assoc_name| inclusions&.exclude?(assoc_name) }
+      sequence = (col_keys - composite_bt_cols) +
+                 composite_bt_names.keys + cust_cols.keys + hots +
+                 hms_keys.reject { |assoc_name| inclusions&.exclude?(assoc_name) }
     end
     sequence.reject! { |nm| exclusions.include?(nm) } if exclusions
     out << sequence.each_with_object(+'') do |col_name, s|
-           if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
-             s << '<th'
-             s << " title=\"#{col.comment}\"" if col.respond_to?(:comment) && !col.comment.blank?
-             s << if (bt = bts[col_name])
-                    # Allow sorting for any BT except polymorphics
-                    "#{' x-order="' + bt.first.to_s + '"' unless bt[2]}>BT " +
+             if (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
+               s << '<th '
+               s << "title=\"#{col.comment}\"" if col.respond_to?(:comment) && !col.comment.blank?
+               s << if (bt = bts[col_name])
+                      # Allow sorting for any BT except polymorphics
+                      "x-order=\"#{bt.first.to_s + '"' unless bt[2]}>BT " +
+                      bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
+                    else # Normal column
+                      "x-order=\"#{col_name + '"' if true}>#{col_name}"
+                    end
+             elsif col # HM column
+               options = {}
+               options[col[1].inheritance_column] = col[1].name unless col[1] == col[1].base_class
+               s << "<th x-order=\"#{col_name + '"' if true}>#{col[2]} "
+               s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path", options))}")
+             elsif cust_cols.key?(col_name) # Custom column
+               s << "<th x-order=\"#{col_name}\">#{col_name}"
+             elsif col_name.is_a?(Symbol) && (hot = bts[col_name]) # has_one :through
+               s << "<th x-order=\"#{hot.first.to_s}\">HOT " +
+                    hot[1].map { |hot_pair| hot_pair.first.bt_link(col_name) }.join(' ')
+             elsif (bt = composite_bt_names[col_name])
+               s << "<th x-order=\"#{bt.first.to_s + '"' unless bt[2]}>BT comp " +
                     bt[1].map { |bt_pair| bt_pair.first.bt_link(bt.first) }.join(' ')
-                  else # Normal column
-                    "#{' x-order="' + col_name + '"' if true}>#{col_name}"
-                  end
-           elsif col # HM column
-             options = {}
-             options[col[1].inheritance_column] = col[1].name unless col[1] == col[1].base_class
-             s << "<th#{' x-order="' + col_name + '"' if true}>#{col[2]} "
-             s << (col.first ? "#{col[3]}" : "#{link_to(col[3], send("#{col[1]._brick_index}_path", options))}")
-           elsif cust_cols.key?(col_name) # Custom column
-             s << "<th x-order=\"#{col_name}\">#{col_name}"
-           elsif col_name.is_a?(Symbol) && (hot = bts[col_name]) # has_one :through
-             s << "<th x-order=\"#{hot.first.to_s}\">HOT " +
-                  hot[1].map { |hot_pair| hot_pair.first.bt_link(col_name) }.join(' ')
-             hot[1].first
-           else # Bad column name!
-             s << "<th title=\"<< Unknown column >>\">#{col_name}"
+             else # Bad column name!
+               s << "<th title=\"<< Unknown column >>\">#{col_name}"
+             end
+             s << '</th>'
            end
-           s << '</th>'
-         end
     out << "</tr></thead>
   <tbody>"
     # %%% Have once gotten this error with MSSQL referring to http://localhost:3000/warehouse/cold_room_temperatures__archive
@@ -70,7 +80,7 @@ module Brick::Rails::FormTags
         out << ' class=\"dimmed\"' unless cols.key?(col_name) || (cust_col = cust_cols[col_name]) ||
                                           (col_name.is_a?(Symbol) && bts.key?(col_name)) # HOT
         out << '>'
-        if (bt = bts[col_name])
+        if (bt = bts[col_name] || composite_bt_names[col_name])
           if bt[2] # Polymorphic?
             if (poly_id = obj.send("#{bt.first}_id"))
               # Was:  obj.send("#{bt.first}_type")
@@ -119,8 +129,12 @@ module Brick::Rails::FormTags
           end
         elsif (col = cols[col_name]).is_a?(ActiveRecord::ConnectionAdapters::Column)
           # binding.pry if col.is_a?(Array)
-          col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
-          out << display_value(col_type || col&.sql_type, val).to_s
+          out << if @_brick_monetized_attributes&.include?(col_name)
+                   val ? Money.new(val.to_i).format : ''
+                 else
+                   col_type = col&.sql_type == 'geography' ? col.sql_type : col&.type
+                   display_value(col_type || col&.sql_type, val).to_s
+                 end
         elsif cust_col
           data = cust_col.first.map { |cc_part| obj.send(cc_part.last) }
           cust_txt = klass.brick_descrip(cust_col[-2], data)

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -218,7 +218,8 @@ module Brick
               puts "  belongs_to :#{a.name}, polymorphic: true"
             end
           else
-            s.first[a.foreign_key.to_s] = [a.name, a.klass]
+            bt_key = a.foreign_key.is_a?(Array) ? a.foreign_key : a.foreign_key.to_s
+            s.first[bt_key] = [a.name, a.klass]
           end
         else # This gets all forms of has_many and has_one
           if through # has_many :through or has_one :through
@@ -525,7 +526,7 @@ module Brick
             v.each do |type|
               # 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)
+                          ::Brick.config.sti_namespace_prefixes.find { |k, _v| k.end_with?('::') && 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
@@ -605,7 +606,8 @@ In config/initializers/brick.rb appropriate entries would look something like:
           ::Rails.configuration.eager_load_namespaces.select { |ns| ns < ::Rails::Application }.each(&:eager_load!)
         end
       else
-        Zeitwerk::Loader.eager_load_all
+        # Same as:  Zeitwerk::Loader.eager_load_all -- plus retry when something skips a beat
+        Zeitwerk::Registry.loaders.each { |loader| load_with_retry(loader) }
       end
       abstract_ar_bases = if do_ar_abstract_bases
                             ActiveRecord::Base.descendants.select { |ar| ar.abstract_class? }.map(&:name)
@@ -614,6 +616,20 @@ In config/initializers/brick.rb appropriate entries would look something like:
       abstract_ar_bases
     end
 
+    # Some classes (like Phlex::Testing::Rails) will successfully auto-load after a retry
+    def load_with_retry(loader, autoloaded = nil)
+      autoloaded ||= loader.send(:autoloaded_dirs).dup
+      begin
+        loader.eager_load
+      rescue Zeitwerk::SetupRequired
+        # This is fine -- we eager load what can be eager loaded
+      rescue Zeitwerk::NameError
+        if autoloaded != (new_auto = loader.send(:autoloaded_dirs))
+          load_with_retry(loader, new_auto.dup) # Try one more time and it could come together
+        end
+      end
+    end
+
     def display_classes(prefix, rels, max_length)
       rels.sort.each do |rel|
         ::Brick.auto_models << rel.first

metadata

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