brick 1.0.156 → 1.0.158

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e001ce24602c8fef817c24a0eb88e014e990d98828474acd66d868b50dd68692
-  data.tar.gz: 8378593754641ffc86059672fe6148ba767d91a867361b21ec8377a82903af6b
+  metadata.gz: 326ec09b1c28cf7c54e54bae9ea6ceed7d7e476a177be0a41af14e04f7cc3d11
+  data.tar.gz: 0507c22a2acf86c58737ecfedeb1a1f5ed6979b5263b28c6d6e77b0e9500ab7c
 SHA512:
-  metadata.gz: 84fa7d9831dfca26b9b08ef46bd852c3d4f96e1f8420ff086526f97964090b3f95d71b5d66d9ff7ba47ec5f74e50938c9714731d21d0c59ac2365305ab8826bc
-  data.tar.gz: cf790bbb66852142fe07cb1619517043dc3ef8c47b0f020b22bc635cd902fface9b52631507b2fdd9520b604c98eae00b58a1bad29ace185c8d342e79e99a062
+  metadata.gz: d6803593a5c3e17ef40005c405017ed4e7519024ca172a077ad377c201a7b2e2caf2a8b4bc5a0ef63f091124a44199ffd3b386db7d6b5d51352f2e3327537d81
+  data.tar.gz: 486b0a15422b0d3150b575c8d19c24cc3434e3fd8f35335d2e490e1e69e423995a2032de913def73b4f4df0e2789c6f4af7d61930db5cc144d0a0cb76be3ebdc

data/lib/brick/config.rb

@@ -332,6 +332,14 @@ module Brick
       @mutex.synchronize { @table_name_prefixes = value }
     end
 
+    def treat_as_module
+      @mutex.synchronize { @treat_as_module || [] }
+    end
+
+    def treat_as_module=(mod_names)
+      @mutex.synchronize { @treat_as_module = mod_names }
+    end
+
     def order
       @mutex.synchronize { @order || {} }
     end

data/lib/brick/extensions.rb

@@ -59,7 +59,7 @@ module ActiveRecord
       end
 
       def is_brick?
-        instance_variables.include?(:@_brick_built) && instance_variable_get(:@_brick_built)
+        instance_variables.include?(:@_brick_relation) && instance_variable_get(:@_brick_relation)
       end
 
       def _assoc_names
@@ -89,6 +89,13 @@ module ActiveRecord
       def brick_foreign_type(assoc)
         reflect_on_association(assoc).foreign_type || "#{assoc}_type"
       end
+
+      def _brick_all_fields
+        rtans = if respond_to?(:rich_text_association_names)
+                  rich_text_association_names&.map { |rtan| rtan.to_s.start_with?('rich_text_') ? rtan[10..-1] : rtan }
+                end
+        columns_hash.keys.map(&:to_sym) + (rtans || [])
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -357,7 +364,7 @@ module ActiveRecord
               # Support nested attributes which use the friendly_id gem
               assoc.klass._brick_nested_friendly_id if Object.const_defined?('FriendlyId') &&
                                                        assoc.klass.instance_variable_get(:@friendly_id_config)
-              new_attrib_text = assoc.klass._brick_find_permits(assoc, (new_permits = assoc.klass.columns_hash.keys.map(&:to_sym)), done_permits)
+              new_attrib_text = assoc.klass._brick_find_permits(assoc, (new_permits = assoc.klass._brick_all_fields), done_permits)
               new_permits << :_destroy
               current_permits << { "#{assoc.name}_attributes".to_sym => new_permits }
               s << "#{assoc.name}_attributes: #{new_attrib_text}"
@@ -544,11 +551,9 @@ module ActiveRecord
       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',
-                 '_brick_is_api', 'controller', 'action'].include?(k)
+        next unless k.start_with?('__')
 
+        k = k[2..-1] # Take off leading "__"
         if (where_col = (ks = k.split('.')).last)[-1] == '!'
           where_col = where_col[0..-2]
         end
@@ -1163,6 +1168,9 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
 end
 
 ::Brick::ADD_CONST_MISSING = lambda do
+  return if @_brick_const_missing_done
+
+  @_brick_const_missing_done = true
   alias _brick_const_missing const_missing
   def const_missing(*args)
     requested = args.first.to_s
@@ -1187,9 +1195,13 @@ end
     end
     base_module = if self < ActiveRecord::Migration || !self.name
                     brick_root || Object
-                  elsif (split_self_name || self.name.split('::')).length > 1 # Classic mode
+                  elsif split_self_name&.length&.> 1 # Classic mode
                     begin
-                      return self._brick_const_missing(*args)
+                      base = self
+                      unless (base_goal = requested.split('::')[0..-2].join('::')).empty?
+                        base = base.parent while base.name != base_goal && base != Object
+                      end
+                      return base._brick_const_missing(*args)
 
                     rescue NameError # %%% Avoid the error "____ cannot be autoloaded from an anonymous class or module"
                       return self.const_get(args.first) if self.const_defined?(args.first)
@@ -1294,10 +1306,16 @@ end
                # Build out a module for the schema if it's namespaced
                # schema_name = schema_name.camelize
                base_module.const_set(schema_name.to_sym, (built_module = Module.new))
-
                [built_module, "module #{schema_name}; end\n"]
                # %%% Perhaps an option to use the first module just as schema, and additional modules as namespace with a table name prefix applied
 
+             # MODULE (overrides from "treat_as_module")
+             elsif (::Brick.enable_models? || ::Brick.enable_controllers?) &&
+                   (possible_module = (base_module == Object ? '' : "#{base_module.name}::") + class_name) &&
+                   ::Brick.config.treat_as_module.include?(possible_module)
+               base_module.const_set(class_name.to_sym, (built_module = Module.new))
+               [built_module, "module #{possible_module}; end\n"]
+
              # AVO Resource
              elsif base_module == Object && Object.const_defined?('Avo') && ::Avo.respond_to?(:railtie_namespace) && requested.end_with?('Resource') &&
                    # Expect that anything called MotorResource or SpinaResource could be from those administrative gems
@@ -1469,6 +1487,7 @@ class Object
       code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
         (schema_module || Object).const_set((chosen_name = (inheritable_name || model_name)).to_sym, new_model_class)
+        @_brick_relation = relation
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
             super(subclass)
@@ -1478,7 +1497,7 @@ class Object
               puts "should be \"class #{model_name} < #{inheritable_name}\"\n           (not \"#{subclass.name} < #{inheritable_name}\")"
             end
           end
-          self.abstract_class = true
+          new_model_class.abstract_class = true
           code << "  self.abstract_class = true\n"
         elsif Object.const_defined?('BCrypt') && relation[:cols].include?('password_digest') &&
               !instance_methods.include?(:password) && respond_to?(:has_secure_password)
@@ -1489,7 +1508,7 @@ class Object
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || self.table_name != matching
         if (inh_col = ::Brick.config.sti_type_column.find { |_k, v| v.include?(matching) }&.first)
-          self.inheritance_column = inh_col
+          new_model_class.inheritance_column = inh_col
           code << "  self.inheritance_column = '#{inh_col}'\n"
         end
 
@@ -1542,19 +1561,19 @@ class Object
         unless is_sti
           fks = relation[:fks] || {}
           # Do the bulk of the has_many / belongs_to processing, and store details about HMT so they can be done at the very last
-          fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts|
-            # The key in each hash entry (fk.first) is the constraint name
-            inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
-            if (invs = assoc[:inverse_table]).is_a?(Array)
-              if assoc[:is_bt]
-                invs = invs.first # Just do the first one of what would be multiple identical polymorphic belongs_to
-              else
-                invs.each { |inv| build_bt_or_hm(full_name, relations, relation, hmts, assoc, inverse_assoc_name, inv, code) }
-              end
-            end
-            build_bt_or_hm(full_name, relations, relation, hmts, assoc, inverse_assoc_name, invs, code) unless invs.is_a?(Array)
-            hmts
-          end
+          hmts = fks.each_with_object(Hash.new { |h, k| h[k] = [] }) do |fk, hmts2|
+                   # The key in each hash entry (fk.first) is the constraint name
+                   inverse_assoc_name = (assoc = fk.last)[:inverse]&.fetch(:assoc_name, nil)
+                   if (invs = assoc[:inverse_table]).is_a?(Array)
+                     if assoc[:is_bt]
+                       invs = invs.first # Just do the first one of what would be multiple identical polymorphic belongs_to
+                     else
+                       invs.each { |inv| build_bt_or_hm(full_name, relations, relation, hmts2, assoc, inverse_assoc_name, inv, code) }
+                     end
+                   else
+                     build_bt_or_hm(full_name, relations, relation, hmts2, assoc, inverse_assoc_name, invs, code)
+                   end
+                 end
           # # Not NULLables
           # # %%% For the minute we've had to pull this out because it's been troublesome implementing the NotNull validator
           # relation[:cols].each do |col, datatype|
@@ -1572,58 +1591,54 @@ class Object
         #   self.broadcasts_to ->(model) { (model&.class&.name || chosen_name).underscore.pluralize.to_sym }
         #   code << "  broadcasts_to ->(#{chosen_name}) { #{chosen_name}&.class&.name&.underscore&.pluralize&.to_sym }\n"
         # end
-      end # class definition
-      # Having this separate -- will this now work out better?
-        built_model.class_exec do
-          @_brick_built = true
-          @_brick_relation = relation
-          hmts&.each do |hmt_fk, hms|
-            hmt_fk = hmt_fk.tr('.', '_')
-            hms.each do |hm|
-              # %%% Need to confirm that HMTs work when they are built from has_manys with custom names
-              through = ::Brick.config.schema_behavior[:multitenant] ? hm.first[:assoc_name] : hm.first[:inverse_table].tr('.', '_').pluralize
-              options = {}
-              hmt_name = if hms.length > 1
-                           if hms[0].first[:inverse][:assoc_name] == hms[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
-                             "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
-                           else # Use BT names to provide uniqueness
-                             if self.name.underscore.singularize == hm.first[:alternate_name]
-                               #  Has previously been:
-                               # # If it folds back on itself then look at the other side
-                               # # (At this point just infer the source be the inverse of the first has_many that
-                               # # we find that is not ourselves.  If there are more than two then uh oh, can't
-                               # # yet handle that rare circumstance!)
-                               # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
-                               # options[:source] = other.first[:inverse][:assoc_name].to_sym
-                               #  And also has been:
-                               # hm.first[:inverse][:assoc_name].to_sym
-                               options[:source] = hm.last.to_sym
-                             else
-                               through = hm.first.fetch(:alternate_chosen_name, hm.first[:alternate_name])
-                             end
-                             singular_assoc_name = hm.first[:inverse][:assoc_name].singularize
-                             "#{singular_assoc_name}_#{hmt_fk}"
-                           end
-                         else
-                           hmt_fk
-                         end
-              options[:through] = through.to_sym
-              if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
-                hmt_name = "#{hmt_name.singularize}_#{hm.first[:assoc_name]}"
-                # Was:
-                # options[:class_name] = hm.first[:inverse_table].singularize.camelize
-                # options[:foreign_key] = hm.first[:fk].to_sym
-                far_assoc = relations[hm.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == hm.last }
-                options[:class_name] = far_assoc.last[:inverse_table].singularize.camelize
-                options[:foreign_key] = far_assoc.last[:fk].to_sym
-              end
-              options[:source] ||= hm.last.to_sym unless hmt_name.singularize == hm.last
-              code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
-              self.send(:has_many, hmt_name.to_sym, **options)
+
+        hmts&.each do |hmt_fk, hms|
+          hmt_fk = hmt_fk.tr('.', '_')
+          hms.each do |hm|
+            # %%% Need to confirm that HMTs work when they are built from has_manys with custom names
+            through = ::Brick.config.schema_behavior[:multitenant] ? hm.first[:assoc_name] : hm.first[:inverse_table].tr('.', '_').pluralize
+            options = {}
+            hmt_name = if hms.length > 1
+                          if hms[0].first[:inverse][:assoc_name] == hms[1].first[:inverse][:assoc_name] # Same BT names pointing back to us? (Most common scenario)
+                            "#{hmt_fk}_through_#{hm.first[:assoc_name]}"
+                          else # Use BT names to provide uniqueness
+                            if self.name.underscore.singularize == hm.first[:alternate_name]
+                              #  Has previously been:
+                              # # If it folds back on itself then look at the other side
+                              # # (At this point just infer the source be the inverse of the first has_many that
+                              # # we find that is not ourselves.  If there are more than two then uh oh, can't
+                              # # yet handle that rare circumstance!)
+                              # other = hms.find { |hm1| hm1 != hm } # .first[:fk]
+                              # options[:source] = other.first[:inverse][:assoc_name].to_sym
+                              #  And also has been:
+                              # hm.first[:inverse][:assoc_name].to_sym
+                              options[:source] = hm.last.to_sym
+                            else
+                              through = hm.first.fetch(:alternate_chosen_name, hm.first[:alternate_name])
+                            end
+                            singular_assoc_name = hm.first[:inverse][:assoc_name].singularize
+                            "#{singular_assoc_name}_#{hmt_fk}"
+                          end
+                        else
+                          hmt_fk
+                        end
+            options[:through] = through.to_sym
+            if relation[:fks].any? { |k, v| v[:assoc_name] == hmt_name }
+              hmt_name = "#{hmt_name.singularize}_#{hm.first[:assoc_name]}"
+              # Was:
+              # options[:class_name] = hm.first[:inverse_table].singularize.camelize
+              # options[:foreign_key] = hm.first[:fk].to_sym
+              far_assoc = relations[hm.first[:inverse_table]][:fks].find { |_k, v| v[:assoc_name] == hm.last }
+              options[:class_name] = far_assoc.last[:inverse_table].singularize.camelize
+              options[:foreign_key] = far_assoc.last[:fk].to_sym
             end
+            options[:source] ||= hm.last.to_sym unless hmt_name.singularize == hm.last
+            code << "  has_many :#{hmt_name}#{options.map { |opt| ", #{opt.first}: #{opt.last.inspect}" }.join}\n"
+            new_model_class.send(:has_many, hmt_name.to_sym, **options)
           end
         end
         code << "end # model #{full_name}\n"
+      end # model class definition
       [built_model, code]
     end
 
@@ -2144,7 +2159,18 @@ class Object
           code << "  end\n"
           self.define_method :new do
             _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
-            if (new_obj = model.new).respond_to?(:serializable_hash)
+            new_params = model.attribute_names.each_with_object({}) do |a, s|
+              if (val = params["__#{a}"])
+                # val = case new_obj.class.column_for_attribute(a).type
+                #       when :datetime, :date, :time, :timestamp
+                #         val.
+                #       else
+                #         val
+                #       end
+                s[a] = val
+              end
+            end
+            if (new_obj = model.new(new_params)).respond_to?(:serializable_hash)
               # Convert any Filename objects with nil into an empty string so that #encode can be called on them
               new_obj.serializable_hash.each do |k, v|
                 new_obj.send("#{k}=", ActiveStorage::Filename.new('')) if v.is_a?(ActiveStorage::Filename) && !v.instance_variable_get(:@filename)
@@ -2291,7 +2317,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits_txt = model._brick_find_permits(model, permits = model.columns_hash.keys.map(&:to_sym))
+            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields)
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
             code << "  end\n"

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

@@ -713,12 +713,9 @@ window.addEventListener(\"popstate\", linkSchemas);
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :has_many
-                                            source.inverse_of&.name # For HM -> HM style HMT
-                                          else # belongs_to or has_one
-                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
-                                          end
-                                 # If there is no inverse available for the source belongs_to association, make one based on the class name
+                                 # Should handle standard HMT, which is HM -> BT, as well as HM -> HM style HMT
+                                 tbl_nm = hm_assoc.source_reflection&.inverse_of&.name
+                                 # If there is no inverse available for the source belongs_to association, infer one based on the class name
                                  unless tbl_nm
                                    tbl_nm = associative.class_name.underscore
                                    tbl_nm.slice!(0) if tbl_nm[0] == '/'
@@ -750,12 +747,12 @@ window.addEventListener(\"popstate\", linkSchemas);
                                      (hm_fk_name.is_a?(String) && hm_fk_name.include?('.')) # HMT?  (Could do a better check for this)
                                     predicates = path_keys(hm_assoc, hm_fk_name, pk).map do |k, v|
                                                    if v == '[sti_type]'
-                                                     "'#{k}': (@#{obj_name}.#{hm_assoc.active_record.inheritance_column})&.constantize&.base_class&.name"
+                                                     "'__#{k}': (@#{obj_name}.#{hm_assoc.active_record.inheritance_column})&.constantize&.base_class&.name"
                                                    else
-                                                     v.is_a?(String) ? "'#{k}': '#{v}'" : "'#{k}': @#{obj_name}.#{v}"
+                                                     v.is_a?(String) ? "'__#{k}': '#{v}'" : "'__#{k}': @#{obj_name}.#{v}"
                                                    end
                                                  end.join(', ')
-                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path({ #{predicates} }) %>\n"
+                                    "<%= link_to '#{assoc_name}', #{hm_assoc.klass._brick_index}_path(predicates = { #{predicates} }) %>\n"
                                   else
                                     puts "Warning:  has_many :#{hm_assoc.name} in model #{hm_assoc.active_record.name} currently looks for a foreign key called \"#{hm_assoc.foreign_key}\".  "\
                                          "Instead it should use the clause  \"foreign_key: :#{hm_assoc.inverse_of&.foreign_key}\"."
@@ -897,6 +894,9 @@ tr th {
 tr th a {
   color: #80FFB8;
 }
+.add-hm-related {
+  float: right;
+}
 
 tr th, tr td {
   padding: 0.2em 0.5em;
@@ -1169,7 +1169,10 @@ if (window.brickFontFamily) {
       x.style.fontFamily = brickFontFamily.toString();
   });
 }
-</script>"
+</script>
+<% if (apartment_default_schema = ::Brick.apartment_multitenant && ::Brick.apartment_default_tenant)
+     Apartment::Tenant.switch!(apartment_default_schema)
+   end %>"
 
               erd_markup = if @_brick_model
                              "<div id=\"mermaidErd\" class=\"mermaid\">
@@ -1658,7 +1661,7 @@ end
      # path_options = [obj.#{pk}]
      # path_options << { '_brick_schema':  } if
      options = {}
-     if ::Brick.config.path_prefix
+     if ::Brick.config.path_prefix || (obj.class.table_name.singularize == obj.class.table_name)
        path_helper = obj.new_record? ? #{model_name}._brick_index : #{model_name}._brick_index(:singular)
        options[:url] = send(\"#\{path_helper}_path\".to_sym, obj)
      end
@@ -1673,12 +1676,22 @@ end
          @#{obj_name}.send(\"#\{model.brick_foreign_type(v.first)}=\", v[1].first&.first&.name)
        end
      end if @#{obj_name}.new_record?
-     @#{obj_name}.attributes.each do |k, val|
-       next if !(col = #{model_name}.columns_hash[k]) ||
-               (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
-               ::Brick.config.metadata_columns.include?(k) %>
+     rtans = #{model_name}.rich_text_association_names if #{model_name}.respond_to?(:rich_text_association_names)
+     (#{model_name}.column_names + (rtans || [])).each do |k|
+       next if (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
+               ::Brick.config.metadata_columns.include?(k)
+
+       col = #{model_name}.columns_hash[k]
+       if !col && rtans&.include?(k)
+         k = k[10..-1] if k.start_with?('rich_text_')
+         col = (rt_col ||= ActiveRecord::ConnectionAdapters::Column.new(
+                             '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: 'varchar', type: :text)
+                           )
+               )
+       end
+       val = @#{obj_name}.attributes[k] %>
     <tr>
-    <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
+    <th class=\"show-field\"<%= \" title=\\\"#\{col&.comment}\\\"\".html_safe if col&.respond_to?(:comment) && !col&.comment.blank? %>>
 <%    has_fields = true
       if (bt = bts[k])
         # Add a final member in this array with descriptive options to be used in <select> drop-downs
@@ -1710,7 +1723,7 @@ end
           collection&.brick_(:each) do |obj|
             option_detail << [
               obj.brick_descrip(
-                descrip_cols&.first&.map { |col| obj.send(col.last) },
+                descrip_cols&.first&.map { |col2| obj.send(col2.last) },
                 obj_pk
               ), obj.send(obj_pk)
             ]
@@ -1763,7 +1776,14 @@ end
                      end"}"
                  end
       s << "<table id=\"#{hm_name}\" class=\"shadow\">
-        <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}</th></tr>
+        <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}
+          <span class = \"add-hm-related\"><%=
+            pk_val = (obj_pk = model.primary_key).is_a?(String) ? obj.send(obj_pk) : obj_pk.map { |pk_part| obj.send(pk_part) }
+            pk_val_arr = [pk_val] unless pk_val.is_a?(Array)
+            link_to('<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\"><path fill=\"#fff\" d=\"M24 10h-10v-10h-4v10h-10v4h10v10h4v-10h10z\"/></svg>'.html_safe,
+              new_#{hm.first.klass._brick_index(:singular)}_path(predicates))
+          %></span>
+        </th></tr>
         <% if (assoc = @#{obj_name}.class.reflect_on_association(:#{hm_name})).macro == :has_one &&
               assoc.options&.fetch(:through, nil).nil?
              # In order to apply DSL properly, evaluate this HO the other way around as if it were as a BT
@@ -2034,9 +2054,7 @@ document.querySelectorAll(\"input, select\").forEach(function (inp) {
               alias _brick_render_template render_template
               def render_template(view, template, layout_name, *args)
                 layout_name = nil if (is_brick = template.instance_variable_get(:@is_brick)) && layout_name.is_a?(Proc)
-                result = _brick_render_template(view, template, layout_name, *args)
-                Apartment::Tenant.switch!(::Brick.apartment_default_tenant) if is_brick && ::Brick.apartment_multitenant
-                result
+                _brick_render_template(view, template, layout_name, *args)
               end
           end # TemplateRenderer
         end

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

@@ -20,7 +20,14 @@ module Brick::Rails::FormBuilder
 
       html_options[:prompt] = "Select #{bt_name}"
       out << self.select(method.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options)
-      bt_link = if (bt_obj = bt_class&.find_by(bt_pair[1] => val))
+      bt_obj = nil
+      begin
+        bt_obj = bt_class&.find_by(bt_pair[1] => val)
+      rescue ActiveRecord::SubclassNotFound => e
+        # %%% Would be cool to indicate to the user that a subclass is missing.
+        # Its name starts at:  e.message.index('failed to locate the subclass: ') + 31
+      end
+      bt_link = if bt_obj
                   bt_path = template.send(
                               "#{bt_class.base_class._brick_index(:singular)}_path".to_sym,
                               bt_obj.send(bt_class.primary_key.to_sym)
@@ -71,11 +78,11 @@ module Brick::Rails::FormBuilder
         # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
         # If it's not yet enabled then:  create extension \"uuid-ossp\";
         # ActiveUUID gem created a new :uuid type
-        out << val
+        out << val if val
       when :ltree
         # In Postgres labels of data stored in a hierarchical tree-like structure
         # If it's not yet enabled then:  create extension ltree;
-        out << val
+        out << val if val
       when :binary
         is_revert = false
         if val
@@ -95,12 +102,12 @@ module Brick::Rails::FormBuilder
         else
           eheij = ActiveSupport::JSON::Encoding.escape_html_entities_in_json
           ActiveSupport::JSON::Encoding.escape_html_entities_in_json = false if eheij
-          val_str = val.to_json
+          val_str = val&.to_json
           ActiveSupport::JSON::Encoding.escape_html_entities_in_json = eheij
         end
         # Because there are so danged many quotes in JSON, escape them specially by converting to backticks.
         # (and previous to this, escape backticks with our own goofy code of ^^br_btick__ )
-        out << (json_field = self.hidden_field(method.to_sym, { class: 'jsonpicker', value: val_str.gsub('`', '^^br_btick__').tr('\"', '`').html_safe }))
+        out << (json_field = self.hidden_field(method.to_sym, { class: 'jsonpicker', value: val_str&.gsub('`', '^^br_btick__')&.tr('\"', '`')&.html_safe }))
         out << "<div id=\"_br_json_#{self.field_id(method)}\"></div>"
       else
         is_revert = false

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

@@ -157,7 +157,7 @@ module Brick::Rails::FormTags
                 out << link_to(ho_txt, send("#{hm_klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
               end
             elsif obj.respond_to?(ct_col = hms_col[1].to_sym) && (ct = obj.send(ct_col)&.to_i)&.positive?
-              predicates = hms_col[2].each_with_object({}) { |v, s| s[v.first] = v.last.is_a?(String) ? v.last : obj.send(v.last) }
+              predicates = hms_col[2].each_with_object({}) { |v, s| s["__#{v.first}"] = v.last.is_a?(String) ? v.last : obj.send(v.last) }
               predicates.each { |k, v| predicates[k] = klass.name if v == '[sti_type]' }
               out << "#{link_to("#{ct || 'View'} #{hms_col.first}",
                                 send("#{hm_klass._brick_index}_path".to_sym, predicates))}\n"

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -113,21 +113,23 @@ module Brick
     def set_db_schema(params = nil)
       # If Apartment::Tenant.current is not still the default (usually 'public') then an elevator has brought us into
       # a different tenant.  If so then don't allow schema navigation.
-      chosen = if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' &&
-                  (current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2]
-                                                       .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first) &&
-                  (is_show_schema_list = (apartment_multitenant && current_schema == ::Brick.default_schema)) &&
-                  (schema = (params ? params['_brick_schema'] : ::Brick.default_schema)) &&
-                  ::Brick.db_schemas&.key?(schema)
-                 Apartment::Tenant.switch!(schema)
-                 schema
-               elsif ::Brick.test_schema
-                 is_show_schema_list = true
-                 Apartment::Tenant.switch!(::Brick.test_schema)
-                 ::Brick.test_schema
-               else
-                 current_schema # Just return the current schema
-               end
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && apartment_multitenant
+        current_schema = (ActiveRecord::Base.execute_sql('SELECT current_schemas(true)')
+                                            .first['current_schemas'][1..-2]
+                                            .split(',') - ['pg_catalog', 'pg_toast', 'heroku_ext']).first
+        is_show_schema_list = current_schema == ::Brick.default_schema
+        schema = (is_show_schema_list && params && params['_brick_schema']) || ::Brick.default_schema
+        chosen = if is_show_schema_list && ::Brick.db_schemas&.key?(schema)
+                   Apartment::Tenant.switch!(schema)
+                   schema
+                 elsif ::Brick.test_schema
+                   is_show_schema_list = true
+                   Apartment::Tenant.switch!(::Brick.test_schema)
+                   ::Brick.test_schema
+                 else
+                   current_schema # Just return the current schema
+                 end
+      end
       [chosen == ::Brick.default_schema ? nil : chosen, is_show_schema_list]
     end
 
@@ -219,8 +221,8 @@ module Brick
               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 } }
+              # No need to include models with no table, or subclassed models if their parent is already in the list
+              hm_models.reject! { |m| !m.table_exists? || 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"
@@ -416,6 +418,12 @@ module Brick
       Brick.config.table_name_prefixes = value
     end
 
+    # @api public
+    # Causes Decidim to work with this line:  Brick.treat_as_module = ['Decidim::ContentBlocks']
+    def treat_as_module=(value)
+      Brick.config.treat_as_module = value
+    end
+
     # @api public
     def metadata_columns=(value)
       Brick.config.metadata_columns = value
@@ -1147,8 +1155,11 @@ ActiveSupport.on_load(:active_record) do
         class << self
           def execute_sql(sql, *param_array)
             param_array = param_array.first if param_array.length == 1 && param_array.first.is_a?(Array)
-            if ['OracleEnhanced', 'SQLServer'].include?(ActiveRecord::Base.connection.adapter_name)
+            case ActiveRecord::Base.connection.adapter_name
+            when 'OracleEnhanced', 'SQLServer'
               connection.exec_query(send(:sanitize_sql_array, [sql] + param_array)).rows
+            when 'Trilogy'
+              connection.execute(send(:sanitize_sql_array, [sql] + param_array)).rows
             else
               connection.execute(send(:sanitize_sql_array, [sql] + param_array))
             end
@@ -1452,7 +1463,8 @@ ActiveSupport.on_load(:active_record) do
       class << self
         alias _original_load load
         def load(yaml, *args, **kwargs)
-          if kwargs[:aliases].nil? && caller[0..4].any? { |line| line.end_with?("`database_configuration'") }
+          if kwargs[:aliases].nil? && caller[0..4].any? { |line| line.end_with?("`database_configuration'") ||
+                                                                 line.end_with?("`secrets'") }
             kwargs[:aliases] = true
           end
           _original_load(yaml, *args, **kwargs)

data/lib/generators/brick/install_generator.rb

@@ -28,7 +28,7 @@ module Brick
         relations = ::Brick.relations
         if is_brick_file
           # Need to remove any currently-existing additional_references so that it doesn't cloud the discovery process:
-          ::Brick.config.additional_references.each do |ar|
+          ::Brick.config.additional_references&.each do |ar|
             if (fks = relations.fetch(ar[0], nil)&.fetch(:fks, nil))
               fks.delete(fks.find { |k, v| v[:is_bt] && k.start_with?('(brick) ') && v[:fk] == ar[1] }&.first)
             end