brick 1.0.223 → 1.0.225

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7358b611b9073f3fafe55e9d3ac4b5d19ebba01604607f7aaf51eaa1b514ef6b
-  data.tar.gz: 29adea32add038493e6f65ab1d426b378214861d9e2a61c0892ffee1a65e55bd
+  metadata.gz: 7f82da7422196469fc96ed7e6a720404547125622e4a9221b762d2797ddfa1a1
+  data.tar.gz: 48db61484c3899a2ee44754979eca01442d1c396e2ae10df8c5bb707d45398fa
 SHA512:
-  metadata.gz: c3c21da00d78d98e635c8986c939530fce1f9b18326d4c40c478cb48aa04bd52617c932eea9872f1142180de351d27936f16dd943cc955b3ad714db000800608
-  data.tar.gz: 26ddbd8d7c7378448dadae1cf6d00dad47221fe5059012fc39c0bf6b1b4745ee9fa63f88e76888ff64e873a20d6a4322099817aaadf565a32254cf0e99911dc0
+  metadata.gz: 33e2eb178a7eb4e7c04ea47ee7cb14b732eb43918974ef189f7423615158acae66a6135ba43373cdc30fa6dffff83388e32f3f0610450f6ae46a66dd9e672176
+  data.tar.gz: e7f04e018e0f21780c2d1a6705a5f39b3a62321d7314fb5b3f0924c77ca11344c5a1928231ac39b32daa858e3411cdee9eb8c09d55992677f46384f2e474cdba

data/lib/brick/extensions.rb

@@ -1658,7 +1658,7 @@ class Object
       end
       plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
       # gsub is so that if it's namespaced then we turn the first part into what would be a schema name
-      singular_table_name = ::Brick.table_name_lookup[model_name] || ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
+      singular_table_name = ::Brick.table_name_lookup&.fetch(model_name, nil) || ActiveSupport::Inflector.underscore(model_name).gsub('/', '.')
 
       if base_model
         table_name = base_model.table_name
@@ -2099,7 +2099,7 @@ class Object
     def build_controller(namespace, class_name, plural_class_name, model, relations)
       if (is_avo = (namespace.name == 'Avo' && Object.const_defined?('Avo')))
         # Basic Avo functionality is available via its own generic controller.
-        # (More information on https://docs.avohq.io/2.0/controllers.html)
+        # (More information on https://docs.avohq.io/3.0/controllers.html)
         controller_base = Avo::ResourcesController
       end
       if !model&.table_exists? && (tn = model&.table_name)
@@ -2117,7 +2117,6 @@ class Object
         puts
       end
       table_name = model&.table_name || ActiveSupport::Inflector.underscore(plural_class_name)
-      singular_table_name = ActiveSupport::Inflector.singularize(ActiveSupport::Inflector.underscore(plural_class_name))
       pk = model&._brick_primary_key(relations.fetch(table_name, nil))
       is_postgres = ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       is_mysql = ['Mysql2', 'Trilogy'].include?(ActiveRecord::Base.connection.adapter_name)
@@ -2142,7 +2141,7 @@ class Object
                 cspd.select! { |val| val == "'self'" }
                 cspd << style_value
               else
-                cspd << "'sha256-0Vb7j3kDGE3oNfwMpRLClTSCUo/q74bvbt3p6kG/gkM='"
+                cspd << "'sha256-#{Base64.encode64(Digest.const_get(:SHA256).digest(::Brick::Rails::BRICK_CSS)).chomp}'"
               end
               cspd << 'https://cdn.jsdelivr.net'
             end
@@ -2279,7 +2278,9 @@ class Object
         end
 
         self.protect_from_forgery unless: -> { self.request.format.js? }
-        plural_table_name = table_name.split('.').last.pluralize
+        tn_start = (table_name_split = table_name.split('.')).length > 1 ? -2 : -1
+        plural_table_name = table_name_split[tn_start..-1].join('_').pluralize
+        singular_table_name = plural_table_name.singularize
         unless is_avo
           self.define_method :index do
             request_ver = request.path.split('/')[-2]
@@ -2518,10 +2519,11 @@ class Object
             code << "  def show\n"
             code << "    #{find_by_name = "find_#{singular_table_name}"}\n"
             code << "  end\n"
+            find_obj = "find_#{singular_table_name}"
             self.define_method :show do
               _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
               _, singular_table_name = model.real_singular(params)
-              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+              instance_variable_set("@#{singular_table_name}".to_sym, send(find_obj))
               add_csp_hash("'unsafe-inline'")
             end
           end
@@ -2614,7 +2616,7 @@ class Object
             self.define_method :edit do
               _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
               _, singular_table_name = model.real_singular(params)
-              instance_variable_set("@#{singular_table_name}".to_sym, find_obj)
+              instance_variable_set("@#{singular_table_name}".to_sym, send(find_obj))
               add_csp_hash
             end
 
@@ -2642,7 +2644,7 @@ class Object
               end
 
               _, singular_table_name = model.real_singular(params)
-              instance_variable_set("@#{singular_table_name}".to_sym, (obj = find_obj))
+              instance_variable_set("@#{singular_table_name}".to_sym, (obj = send(find_obj)))
               upd_params = send(params_name_sym)
               json_overrides = ::Brick.config.json_columns&.fetch(table_name, nil)
               if model.respond_to?(:devise_modules)
@@ -2688,7 +2690,7 @@ class Object
             code << "  end\n"
             self.define_method :destroy do
               ::Brick.set_db_schema(params)
-              if (obj = find_obj).send(:destroy)
+              if (obj = send(find_obj)).send(:destroy)
                 redirect_to send("#{model._brick_index}_path".to_sym)
               else
                 redirect_to send("#{model._brick_index(:singular)}_path".to_sym, obj)
@@ -2699,11 +2701,11 @@ class Object
           code << "private\n" if pk.present? || is_need_params
 
           if pk.present?
-            code << "  def find_#{singular_table_name}
+            code << "  def #{find_obj}
     id = params[:id]&.split(/[\\/,_]/)
     @#{singular_table_name} = #{model.name}.find(id.is_a?(Array) && id.length == 1 ? id.first : id)
   end\n"
-            self.define_method :find_obj do
+            self.define_method(find_obj) do
               id = if pk.length == 1 # && model.columns_hash[pk.first]&.type == :string
                      params[:id].gsub('^^sl^^', '/')
                    else
@@ -2723,6 +2725,7 @@ class Object
                 model.find(id_simplified)
               end
             end
+            private find_obj
           end
 
           if is_need_params
@@ -3164,8 +3167,10 @@ module Brick
           begin
             if bt.key?(:polymorphic)
               pri_pk = for_pk
-              pri_tables = Brick.config.polymorphics["#{frn_tbl}.#{bt[:fk]}"]
-                                .each_with_object(Hash.new { |h, k| h[k] = [] }) do |pri_class, s|
+              pri_models = ((frn_class = Object.const_get(v[1][:class_name])).respond_to?(poly_types_method = "#{bt[:assoc_name]}_types") &&
+                            frn_class.send(poly_types_method) # Trust what was set by #delegated_type
+                           ) || Brick.config.polymorphics["#{frn_tbl}.#{bt[:fk]}"]
+              pri_tables = pri_models.each_with_object(Hash.new { |h, k| h[k] = [] }) do |pri_class, s|
                 s[Object.const_get(pri_class).table_name] << pri_class
               end
               fk_id_col = "#{bt[:fk]}_id"

data/lib/brick/rails/engine.rb

@@ -106,6 +106,16 @@ function linkSchemas() {
           load inflections
         end
         require 'brick/join_array'
+
+        # Load it once at the start for Rails >= 7.2 ...
+        Module.class_exec &::Brick::ADD_CONST_MISSING if ActiveRecord.version >= Gem::Version.new('7.2.0')
+        # ... and also for Rails >= 5.0, whenever the app gets reloaded
+        if ::Rails.application.respond_to?(:reloader)
+          ::Rails.application.reloader.to_prepare { Module.class_exec &::Brick::ADD_CONST_MISSING }
+        else
+          Module.class_exec &::Brick::ADD_CONST_MISSING # Older Rails -- just load at the start
+        end
+
         # Now the Brick initializer since there may be important schema things configured
         if !::Brick.initializer_loaded && File.exist?(brick_initializer = ::Rails.root&.join('config/initializers/brick.rb') || '')
           ::Brick.initializer_loaded = load brick_initializer
@@ -180,12 +190,6 @@ function linkSchemas() {
             ::Brick.established_drf = "/#{::Brick.config.path_prefix}#{action[action.index('#')..-1]}"
           end
         end
-
-        Module.class_exec &::Brick::ADD_CONST_MISSING # Load it once at the start ...
-        # ... and also for Rails >= 5.0, whenever the app gets reloaded
-        if ::Rails.application.respond_to?(:reloader)
-          ::Rails.application.reloader.to_prepare { Module.class_exec &::Brick::ADD_CONST_MISSING }
-        end
       end
 
       # After we're initialized and before running the rest of stuff, put our configuration in place
@@ -632,10 +636,17 @@ window.addEventListener(\"popstate\", linkSchemas);
 
             def path_keys(hm_assoc, fk_name, pk)
               pk.map!(&:to_sym)
-              keys = if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
-                       fk_name.zip(pk)
+              keys = if hm_assoc.macro == :has_and_belongs_to_many
+                       # %%% Can a HABTM use composite keys?
+                       # (If so then this should be rewritten to do a .zip() )
+                       name_from_other_direction = hm_assoc.klass.reflect_on_all_associations.find { |a| a.join_table == hm_assoc.join_table }&.name
+                       [["#{name_from_other_direction}.#{pk.first}", pk.first]]
                      else
-                       [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
+                       if fk_name.is_a?(Array) && pk.is_a?(Array) # Composite keys?
+                         fk_name.zip(pk)
+                       else
+                         [[fk_name, pk.length == 1 ? pk.first : pk.inspect]]
+                       end
                      end
               if hm_assoc.options.key?(:as) && !(hmaar = hm_assoc.active_record).abstract_class?
                 poly_type = if hmaar.column_names.include?(hmaar.inheritance_column)
@@ -680,7 +691,10 @@ window.addEventListener(\"popstate\", linkSchemas);
 
               if @_brick_model
                 pk = @_brick_model._brick_primary_key(::Brick.relations.fetch((table_name = @_brick_model.table_name.split('.').last), nil))
-                obj_name = model_name.split('::').last.underscore
+                rn_start = (res_name_split = model_name.split('::')).length > 1 ? -2 : -1
+                obj_name = res_name_split[rn_start..-1].join('_').singularize
+                res_name = obj_name.pluralize
+
                 path_obj_name = @_brick_model._brick_index(:singular)
                 table_name ||= obj_name.pluralize
                 template_link = nil
@@ -689,7 +703,14 @@ window.addEventListener(\"popstate\", linkSchemas);
                 skip_klass_hms = ::Brick.config.skip_index_hms[model_name] || {}
                 hms_headers = hms.each_with_object([]) do |hm, s|
                   hm_stuff = [(hm_assoc = hm.last),
-                              "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]}",
+                              "H#{case hm_assoc.macro
+                                  when :has_one
+                                    'O'
+                                  when :has_and_belongs_to_many
+                                    'ABTM'
+                                  else
+                                    'M'
+                                  end}#{'T' if hm_assoc.options[:through]}",
                               (assoc_name = hm.first)]
                   hm_fk_name = if (through = hm_assoc.options[:through])
                                  next unless @_brick_model.instance_methods.include?(through) &&
@@ -789,9 +810,10 @@ window.addEventListener(\"popstate\", linkSchemas);
                ['Crosstab', is_crosstab]].each do |table_option, show_it|
                 table_options << "<option value=\"#{prefix}brick_#{table_option.downcase}\">(#{table_option})</option>".html_safe if show_it
               end
-              css = +''
+              css = +'<style>'
               css << ::Brick::Rails::BRICK_CSS
-              css << "<script>
+              css << "</style>
+<script>
   if (window.history.state && window.history.state.turbo)
     window.addEventListener(\"popstate\", function () { location.reload(true); });
 </script>
@@ -1022,7 +1044,7 @@ end %>#{"
   end
   \"<tr><td colspan=\\\"#\{td_count}\\\">Children: #\{child_links.join(' ')}</tr>\".html_safe
 end
-%><%= if (page_num = @#{res_name = table_name.pluralize}&._brick_page_num)
+%><%= if (page_num = @#{res_name}&._brick_page_num)
            \"<tr><td colspan=\\\"#\{td_count}\\\">Page #\{page_num}</td></tr>\".html_safe
          end %></table>#{template_link}<%
    if description.present? %><span class=\"__brick\"><%=

data/lib/brick/rails/form_builder.rb

@@ -76,8 +76,12 @@ module Brick::Rails::FormBuilder
           out << self.hidden_field(method.to_sym, html_options)
           out << "<trix-editor input=\"#{self.field_id(method)}\"></trix-editor>"
         end
-        out << self.text_field(method.to_sym, html_options) if spit_out_text_field
-      when :boolean
+        if spit_out_text_field
+          # %%% Need to update the max-width with javascript when page width is adjusted?
+          html_options.merge!(style: 'min-width: 154px;field-sizing: content;') # max-width: auto;
+          out << self.text_field(method.to_sym, html_options)
+        end
+        when :boolean
         out << self.check_box(method.to_sym)
       when :integer, :decimal, :float
         if model.respond_to?(:attribute_types) && (enum_type = model.attribute_types[method]).is_a?(ActiveRecord::Enum::EnumType)

data/lib/brick/rails/form_tags.rb

@@ -517,7 +517,7 @@ module Brick::Rails::FormTags
 
   # All the standard CSS with teal colouration for use with Brick
   def brick_css(theme = nil)
-    ::Brick::Rails::BRICK_CSS.html_safe
+    "<style>#{::Brick::Rails::BRICK_CSS}</style>".html_safe
   end
 
   # -----------------------------------------------------------------------------------------------

data/lib/brick/rails.rb

@@ -167,7 +167,7 @@ erDiagram
 %>    <%= \"#\{through_name} }o--|| #\{hm_name}\".html_safe %> : \"\"
     <%= \"#{model_short_name} }o..o{ #\{hm_name} : \\\"#\{hm.first}\\\"\".html_safe %><%
      else # has_many
-%>  <%= \"#{model_short_name} ||--o{ #\{hm_name} : \\\"#\{
+%>  <%= \"#{model_short_name} #\{hm.last.macro == :has_and_belongs_to_many ? '}o' : '||'}--o{ #\{hm_name} : \\\"#\{
             hm.first.to_s unless (last_hm = hm.first.to_s).downcase == hm_class.name.underscore.pluralize.tr('/', '_')
           }\\\"\".html_safe %><%
      end %>
@@ -289,7 +289,7 @@ erDiagram
 
   # CONSTANTS
 
-  BRICK_CSS = "<style>
+  BRICK_CSS = "
 #titleSticky {
   position: sticky;
   display: inline-block;
@@ -527,7 +527,6 @@ input+svg.revert {
   background-color: #004998;
   color: #FFF;
 }
-</style>
 "
 
   AVO_SVG = "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 84 90\" height=\"30\" fill=\"#3096F7\">

data/lib/brick/route_mapper.rb

@@ -53,7 +53,7 @@ module Brick
           # else
           #   puts "#{'  ' * ind}scope #{scope_options.inspect}"
           # end
-          send(:scope, scope_options) do
+          send(:scope, **scope_options) do
             brick_namespace_create.call(path_names, res_name, options, ind + 1)
           end
         else
@@ -243,7 +243,7 @@ module Brick
             { :index => 'get', :create => 'post' }.each do |action, method|
               if actions.include?(action)
                 # Normally goes to something like:  /api/v1/employees
-                send(method, "#{api_root}#{unversioned.tr('.', '/')}", { to: "#{controller_prefix}#{controller_name}##{action}" })
+                send(method, "#{api_root}#{unversioned.tr('.', '/')}", to: "#{controller_prefix}#{controller_name}##{action}")
               end
             end
             # %%% We do not yet surface the #show action
@@ -251,7 +251,7 @@ module Brick
               { :update => ['put', 'patch'], :destroy => ['delete'] }.each do |action, methods|
                 if actions.include?(action)
                   methods.each do |method|
-                    send(method, "#{api_root}#{unversioned.tr('.', '/')}/:#{id_col}", { to: "#{controller_prefix}#{controller_name}##{action}" })
+                    send(method, "#{api_root}#{unversioned.tr('.', '/')}/:#{id_col}", to: "#{controller_prefix}#{controller_name}##{action}")
                   end
                 end
               end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -248,10 +248,14 @@ module Brick
 
         if a.belongs_to?
           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 = rel_poly_bt[1][:polymorphic]&.map { |table| table.singularize.camelize.constantize }
-              s.first[a.foreign_key.to_s] = [a.name, models, true]
+            if (pri_models = (model.respond_to?(poly_types_method = "#{a.name}_types") &&
+                              model.send(poly_types_method)
+                             ) ||
+                             (rel_poly_bt = relations[model.table_name][:fks].find { |_k, fk| fk[:assoc_name] == a.name.to_s } &&
+                              (rel_poly_bt[1][:polymorphic] || rel_poly_bt&.last&.fetch(:inverse_table, [])&.map { |table| table.singularize.camelize })
+                             )
+               ).is_a?(Array)
+              s.first[a.foreign_key.to_s] = [a.name, pri_models.map(&:constantize), true]
             else
               # 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,
@@ -267,11 +271,19 @@ module Brick
                 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}\" =>
+                puts "Having analyzed all currently-loaded models to infer the various polymorphic has_many associations,"
+                if ActiveRecord::Base.respond_to?(:delegated_type)
+                  puts "in your #{model.name} model file, you can change this line:
+  belongs_to :#{a.name}#{a.options.map { |k, v| ", #{k}: #{v}" }.join}
+to instead be this:
+  delegated_type :#{a.name}, types: #{hm_models.map(&:name).inspect}#{a.options.reject { |k| [:polymorphic, :inverse_of].include?(k) }.map { |k, v| ", #{k}: #{v}" }.join}\n"
+                else
+                  puts "to support the #{model.name} model, you can add this into your brick.rb:
+::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.'
+                puts "and it will \"cement\" these options into place, and avoid this lookup process.\n"
+                end
                 s.first[a.foreign_key.to_s] = [a.name, hm_models, true]
               end
             end
@@ -297,7 +309,7 @@ module Brick
               puts "  due to invalid source #{a.source_reflection_name.inspect}."
               next
             end
-          else
+          elsif a.macro != :has_and_belongs_to_many
             this_fks = (this_fk = a.foreign_key).is_a?(Array) ? this_fk.uniq : [this_fk.to_s]
             if !a.options.key?(:as) && a.klass.table_exists? && (this_fks - a.klass.column_names).length.positive?
               options = ", #{a.options.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}" if a.options.present?

data/lib/generators/brick/install_generator.rb

@@ -386,6 +386,10 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   Brick.config.schema_behavior[:multitenant]&.fetch(:schema_to_analyse, nil).inspect}" :
 "  # Brick.schema_behavior = { multitenant: { schema_to_analyse: 'engineering'"
 } } }
+#{"
+  # # Note that if you have a real polymorphic model configured then it is better to set the list of classes up in the
+  # # model file itself with a line like:
+  # delegated_type :commentable, type: ['Post', 'Comment']" if ActiveRecord::Base.respond_to?(:delegated_type)}
 
   # # DEFAULT ROOT ROUTE
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.223
+  version: 1.0.225
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-13 00:00:00.000000000 Z
+date: 2025-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord