brick 1.0.151 → 1.0.153

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d8abfeb02b561a0ac8214de3c4791992947cab9f288f9f57c816a883dc4592a
-  data.tar.gz: 1ec0f9d11eea9b1741e454ac04aa2c51380a0d9676f4e84a5de2419d3ef751bd
+  metadata.gz: fc98614593bc4e4931a445801f4f7764c15e6032daf2765f8d78a47f61b7b3a7
+  data.tar.gz: 5b3ae1d718df14101c153b335a66578a5b02771714dedd7ebda1022cadebe482
 SHA512:
-  metadata.gz: 758e2ab6e10589689abdb77df64731e3df2fff341998e8f815bd5f180a73df89fb1282155a9520cc43102a49b1f7283114c02146329161e2324fc2fa79c6048e
-  data.tar.gz: 9a77d3d4318943225427c59e676c4a067c95a22351eaea88ed14bbc6da60ee834498117704bc0fe1dd493f6e10ab65a27db4bff3b060440f4e7dfaf3b31ad184
+  metadata.gz: 15852e3d59a95d5ac8614d98a44a70796c5494610447505abe61dcd02010c3701dc9ba48da951e4639e4fa14694cfee4c7455c2a0bd63fc613738886ca908b26
+  data.tar.gz: bd5cc34b7c004461af1737dbcb4b746889bd7f4da7d5242c3f341793ed4675c33a50bc61108a6f1e24037585298361f8f4f6ac699a25a72c4ec860f1c272e0ba

data/lib/brick/config.rb

@@ -204,6 +204,15 @@ module Brick
       @mutex.synchronize { @has_ones = hos }
     end
 
+    # Associations upon which to add #accepts_nested_attributes_for logic
+    def nested_attributes
+      @mutex.synchronize { @nested_attributes }
+    end
+
+    def nested_attributes=(anaf)
+      @mutex.synchronize { @nested_attributes = anaf }
+    end
+
     # Polymorphic associations
     def polymorphics
       @mutex.synchronize { @polymorphics }

data/lib/brick/extensions.rb

@@ -344,6 +344,28 @@ module ActiveRecord
       def _br_cust_cols
         @_br_cust_cols ||= {}
       end
+
+      def _brick_find_permits(model_or_assoc, current_permits, done_permits = [])
+        unless done_permits.include?(model_or_assoc)
+          done_permits << model_or_assoc
+          self.reflect_on_all_associations.select { |assoc| !assoc.belongs_to? }.each_with_object([]) do |assoc, s|
+            if assoc.options[:through]
+              current_permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
+              s << "#{assoc.name.to_s.singularize}_ids: []"
+            end
+            if self.instance_methods.include?(:"#{assoc.name}_attributes=")
+              # 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_permits << :_destroy
+              current_permits << { "#{assoc.name}_attributes".to_sym => new_permits }
+              s << "#{assoc.name}_attributes: #{new_attrib_text}"
+            end
+          end
+        end
+        current_permits
+      end
     end
 
     # Search for custom column, BT, HM, and HMT DSL stuff
@@ -1222,25 +1244,38 @@ end
     result = if ::Brick.enable_controllers? &&
                 is_controller && (plural_class_name = class_name[0..-11]).length.positive?
                # Otherwise now it's up to us to fill in the gaps
+               controller_class_name = +''
                full_class_name = +''
-               full_class_name << "::#{(split_self_name&.first && split_self_name.join('::')) || self.name}" unless self == Object
+               unless self == Object
+                 controller_class_name << ((split_self_name&.first && split_self_name.join('::')) || self.name)
+                 full_class_name << "::#{controller_class_name}"
+                 controller_class_name << '::'
+               end
                # (Go over to underscores for a moment so that if we have something come in like VABCsController then the model name ends up as
                # Vabc instead of VABC)
                singular_class_name = ::Brick.namify(plural_class_name, :underscore).singularize.camelize
                full_class_name << "::#{singular_class_name}"
+               skip_controller = nil
                if plural_class_name == 'BrickOpenapi' ||
                   (
                     (::Brick.config.add_status || ::Brick.config.add_orphans) &&
                     plural_class_name == 'BrickGem'
                   ) ||
-                  model = self.const_get(full_class_name)
-                 # In the very rare case that we've picked up a MODULE which has the same name as what would be the
-                 # resource's MODEL name, just build out an appropriate auto-model on-the-fly. (RailsDevs code has this in PayCustomer.)
-                 # %%% We don't yet display the code for this new model
-                 if model && !model.is_a?(Class)
-                   model, _code = Object.send(:build_model, relations, model.module_parent, model.module_parent.name, singular_class_name)
+                 begin
+                   model = self.const_get(full_class_name)
+
+                   # In the very rare case that we've picked up a MODULE which has the same name as what would be the
+                   # resource's MODEL name, just build out an appropriate auto-model on-the-fly. (RailsDevs code has this in PayCustomer.)
+                   # %%% We don't yet display the code for this new model
+                   if model && !model.is_a?(Class)
+                     model, _code = Object.send(:build_model, relations, model.module_parent, model.module_parent.name, singular_class_name)
+                   end
+                 rescue NameError # If the const_get for the model has failed...
+                   skip_controller = true
+                   # ... then just fall through and allow it to fail when trying to loading the ____Controller class normally.
                  end
-                 # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
+               end
+               unless skip_controller
                  Object.send(:build_controller, self, class_name, plural_class_name, model, relations)
                end
 
@@ -1453,7 +1488,7 @@ class Object
           code << "  has_secure_password\n"
         end
         # 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 || table_name != matching
+        code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || self.table_name != matching
 
         # Override models backed by a view so they return true for #is_view?
         # (Dynamically-created controllers and view templates for such models will then act in a read-only way)
@@ -1639,18 +1674,23 @@ class Object
                 else
                   need_fk = "#{ActiveSupport::Inflector.singularize(assoc[:inverse][:inverse_table].split('.').last)}_id" != assoc[:fk]
                 end
+                singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name.tr('.', '_'))
                 has_ones = ::Brick.config.has_ones&.fetch(full_name, nil)
-                if has_ones&.key?(singular_assoc_name = ActiveSupport::Inflector.singularize(assoc_name.tr('.', '_')))
-                  assoc_name = if (custom_assoc_name = has_ones[singular_assoc_name])
-                                 need_class_name = custom_assoc_name != singular_assoc_name
-                                 custom_assoc_name
-                               else
-                                 singular_assoc_name
-                               end
-                  :has_one
-                else
-                  :has_many
-                end
+                macro = if has_ones&.key?(singular_assoc_name)
+                          assoc_name = if (custom_assoc_name = has_ones[singular_assoc_name])
+                                        need_class_name = custom_assoc_name != singular_assoc_name
+                                        custom_assoc_name
+                                      else
+                                        singular_assoc_name
+                                      end
+                          :has_one
+                        else
+                          :has_many
+                        end
+                # Auto-create an accepts_nested_attributes_for for this HM?
+                is_anaf = (anaf = ::Brick.config.nested_attributes&.fetch(full_name, nil)) &&
+                          (anaf.is_a?(Array) ? anaf.include?(assoc_name) : anaf == assoc_name)
+                macro
               end
       # Figure out if we need to specially call out the class_name and/or foreign key
       # (and if either of those then definitely also a specific inverse_of)
@@ -1686,6 +1726,10 @@ class Object
       assoc_name = assoc_name.tr('.', '_').to_sym
       code << "  #{macro} #{assoc_name.inspect}#{options.map { |k, v| ", #{k}: #{v.inspect}" }.join}\n"
       self.send(macro, assoc_name, **options)
+      if is_anaf
+        code << "  accepts_nested_attributes_for #{assoc_name.inspect}\n"
+        self.send(:accepts_nested_attributes_for, assoc_name)
+      end
     end
 
     def default_ordering(table_name, pk)
@@ -2194,6 +2238,9 @@ class Object
                   end
                 end
               end
+              if (upd_hash ||= upd_params).fetch(model.inheritance_column, nil)&.strip == ''
+                upd_hash[model.inheritance_column] = nil
+              end
               obj.send(:update, upd_hash || upd_params)
             end
 
@@ -2241,7 +2288,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits_txt = self._brick_find_permits(model, (permits = model.columns_hash.keys.map(&:to_sym)))
+            permits_txt = model._brick_find_permits(model, permits = model.columns_hash.keys.map(&:to_sym))
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
             code << "  end\n"
@@ -2257,27 +2304,6 @@ class Object
       [built_controller, code]
     end
 
-    def _brick_find_permits(model, current_permits, done_permits = [])
-      unless done_permits.include?(self)
-        done_permits << self
-        model.reflect_on_all_associations.select { |assoc| assoc.macro == :has_many }.each_with_object([]) do |assoc, s|
-          if assoc.options[:through]
-            current_permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
-            s << "#{assoc.name.to_s.singularize}_ids: []"
-          elsif assoc.active_record.instance_methods.include?(:"#{assoc.name}_attributes=")
-            # Support nested attributes which use the friendly_id gem
-            self._brick_nested_friendly_id if Object.const_defined?('FriendlyId') &&
-                                              assoc.klass.instance_variable_get(:@friendly_id_config)
-            new_attrib_text = self._brick_find_permits(assoc.klass, (new_permits = assoc.klass.columns_hash.keys.map(&:to_sym)), done_permits)
-            new_permits << :_destroy
-            current_permits << { "#{assoc.name}_attributes".to_sym => new_permits }
-            s << "#{assoc.name}_attributes: #{new_attrib_text}"
-          end
-        end
-      end
-      current_permits
-    end
-
     def _brick_nested_friendly_id
       unless @_brick_nested_friendly_id
         ::ActiveRecord::Base.class_exec do
@@ -2472,6 +2498,11 @@ end.class_exec do
             ::Brick.config.table_name_prefixes[as_tnp] = ar_extension
           end
         end
+
+        # Support the followability gem:  https://github.com/nejdetkadir/followability
+        if Object.const_defined?('Followability') && !::Brick.config.table_name_prefixes.key?('followability_')
+          ::Brick.config.table_name_prefixes['followability_'] = 'Followability'
+        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

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

@@ -257,6 +257,9 @@ function linkSchemas() {
         # Has one relationships
         ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
 
+        # accepts_nested_attributes_for relationships
+        ::Brick.nested_attributes = app.config.brick.fetch(:nested_attributes, nil)
+
         # Polymorphic associations
         ::Brick.polymorphics = app.config.brick.fetch(:polymorphics, nil)
       end
@@ -1683,7 +1686,7 @@ end
         end %>
         BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
     <% else %>
-      <%= k %>
+      <%= #{model_name}.human_attribute_name(k, { default: k }) %>
     <% end %>
     </th>
     <td>

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

@@ -1,7 +1,29 @@
 module Brick::Rails::FormTags
   # Our super speedy grid
-  def brick_grid(relation, bt_descrip, sequence = nil, inclusions, exclusions,
-                 cols, poly_cols, bts, hms_keys, hms_cols)
+  def brick_grid(relation = nil, bt_descrip = nil, sequence = nil, inclusions = nil, exclusions = nil,
+                 cols = {}, poly_cols = nil, bts = {}, hms_keys = [], hms_cols = {})
+    # When a relation is not provided, first see if one exists which matches the controller name
+    unless (relation ||= instance_variable_get("@#{controller_name}".to_sym))
+      # Failing that, dig through the instance variables with hopes to find something that is an ActiveRecord::Relation
+      case (collections = _brick_resource_from_iv).length
+      when 0
+        puts '#brick_grid:  Not having been provided with a collection to work from, searched through all instance variables to find an ActiveRecord::Relation.  None could be found.'
+        return
+      when 1 # If there's only one type match then simply get the first one, hoping that this is what they intended
+        relation = instance_variable_get(iv = (chosen = collections.first).last.first)
+        puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}.
+              Failing that, have searched through instance variables and found #{iv} of type #{chosen.first.name}.
+              Running with it!"
+      else
+        myriad = collections.each_with_object([]) { |c, s| c.last.each { |iv| s << "#{iv} (#{c.first.name})" } }
+        puts "#brick_grid:  Not having been provided with a collection to work from, first tried @#{controller_name}, and then searched through all instance variables.
+              Found ActiveRecord::Relation objects of multiple types:
+                #{myriad.inspect}
+              Not knowing which of these to render, have erred on the side of caution and simply provided this warning message."
+        return
+      end
+    end
+
     out = "<table id=\"headerTop\"></table>
 <table id=\"#{relation.table_name.split('.').last}\" class=\"shadow\">
   <thead><tr>"
@@ -14,8 +36,8 @@ module Brick::Rails::FormTags
     col_keys = relation.columns.each_with_object([]) do |col, s|
       col_name = col.name
       next if inclusions&.exclude?(col_name) ||
-              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts.key?(col_name)) ||
-              ::Brick.config.metadata_columns.include?(col_name) || poly_cols.include?(col_name)
+              (pk.include?(col_name) && [:integer, :uuid].include?(col.type) && !bts&.key?(col_name)) ||
+              ::Brick.config.metadata_columns.include?(col_name) || poly_cols&.include?(col_name)
 
       s << col_name
       cols[col_name] = col
@@ -44,7 +66,8 @@ module Brick::Rails::FormTags
                       "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}"
+                      col_name_humanised = klass.human_attribute_name(col_name, { default: col_name })
+                      "x-order=\"#{col_name + '"' if true}>#{col_name_humanised}"
                     end
              elsif col # HM column
                options = {}
@@ -261,16 +284,7 @@ module Brick::Rails::FormTags
     else
       # puts "Warning:  link_to_brick could not find a class for \"#{controller_path}\" -- consider setting @_brick_model within that controller."
       # if (hits = res_names.keys & instance_variables.map { |v| v.to_s[1..-1] }).present?
-      links = instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
-                iv_name = name.to_s[1..-1]
-                case (val = instance_variable_get(name))
-                when ActiveRecord::Relation
-                  s[val.klass] << iv_name
-                when ActiveRecord::Base
-                  s[val] << iv_name
-                end
-              end
-      if links.length == 1 # If there's only one match then use any text that was supplied
+      if (links = _brick_resource_from_iv(true)).length == 1 # If there's only one match then use any text that was supplied
         link_to_brick(text || links.first.last.join('/'), links.first.first, **kwargs)
       else
         links.each_with_object([]) { |v, s| s << link if link = link_to_brick(v.join('/'), v, **kwargs) }.join(' &nbsp; ').html_safe
@@ -278,4 +292,17 @@ module Brick::Rails::FormTags
     end
   end # link_to_brick
 
+private
+
+  def _brick_resource_from_iv(trim_ampersand = false)
+    instance_variables.each_with_object(Hash.new { |h, k| h[k] = [] }) do |name, s|
+      iv_name = trim_ampersand ? name.to_s[1..-1] : name
+      case (val = instance_variable_get(name))
+      when ActiveRecord::Relation
+        s[val.klass] << iv_name
+      when ActiveRecord::Base
+        s[val] << iv_name
+      end
+    end
+  end
 end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -192,10 +192,17 @@ module Brick
           puts "Based on inclusion in ::Brick.polymorphics, marking association #{full_assoc_name} as being polymorphic."
           a.options[:polymorphic] = true
         end
-        next unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
-                    (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
-                     (!a.belongs_to? || model_cols[a.foreign_key]&.type == pk_type)
-                    )
+        unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
+               (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
+                 (!a.belongs_to? || (same_type = (fk_type = model_cols[a.foreign_key]&.type) == pk_type))
+               )
+          if same_type == false # We really do want to test specifically for false here, and not nil!
+            puts "WARNING:
+  Foreign key column #{a.klass.table_name}.#{a.foreign_key} is #{fk_type}, but the primary key it relates to, #{a.active_record.table_name}.#{a.active_record.primary_key}, is #{pk_type}.
+  These columns should both be of the same type."
+          end
+          next
+        end
 
         if a.belongs_to?
           if a.polymorphic?
@@ -477,6 +484,12 @@ module Brick
       end
     end
 
+    # Associations upon which to add #accepts_nested_attributes_for logic
+    # @api public
+    def nested_attributes=(anaf)
+      Brick.config.nested_attributes = anaf
+    end
+
     # Polymorphic associations
     def polymorphics=(polys)
       polys = polys.each_with_object({}) { |poly, s| s[poly] = nil } if polys.is_a?(Array)
@@ -1369,14 +1382,18 @@ ActiveSupport.on_load(:active_record) do
     arsc.class_exec do
       def self.create(connection, callable = nil, &block)
         relation = (callable || block).call ::ActiveRecord::StatementCache::Params.new
-        bind_map = ::ActiveRecord::StatementCache::BindMap.new(
-                     # AR <= 4.2 uses relation.bind_values
-                     relation.respond_to?(:bound_attributes) ? relation.bound_attributes : relation.bind_values
-                   )
         options = [self, relation.arel]
         options.shift if connection.method(:cacheable_query).arity == 1 # Rails <= 5.0
         query_builder = connection.cacheable_query(*options)
-        new query_builder, bind_map
+        query_builder, binds = query_builder if query_builder.is_a?(Array) # Accommodate AR < 5.2.4
+
+        bind_map = ::ActiveRecord::StatementCache::BindMap.new(
+                     # AR <= 4.2 uses relation.bind_values
+                     relation.respond_to?(:bound_attributes) ? relation.bound_attributes : (binds || relation.bind_values)
+                   )
+        new_options = [query_builder, bind_map]
+        new_options << relation.klass if binds # Accommodate AR < 5.2.4
+        new(*new_options)
       end
     end
   end

data/lib/generators/brick/install_generator.rb

@@ -19,13 +19,25 @@ module Brick
 
     def create_initializer_file
       is_brick_file = File.exist?(filename = 'config/initializers/brick.rb')
-      if is_brick_file && ::Brick.config.schema_behavior[:multitenant] || !is_brick_file
+      if (is_brick_file && (tnps = ::Brick.config.table_name_prefixes).present?) ||
+                           (::Brick.config.schema_behavior[:multitenant]
+         ) || !is_brick_file
         # See if we can make suggestions for additional_references and polymorphic associations
         resembles_fks = Hash.new { |h, k| h[k] = [] }
         possible_polymorphics = {}
-        possible_additional_references = (relations = ::Brick.relations).each_with_object(Hash.new { |h, k| h[k] = [] }) do |v, s|
-          model_filename = "app/models/#{ActiveSupport::Inflector.singularize(v.first)}.rb"
-          v.last[:cols].each do |col, type|
+        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|
+            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
+          end
+        end
+        possible_additional_references = relations.each_with_object(Hash.new { |h, k| h[k] = [] }) do |relation, s|
+          this_tnp = tnps&.keys.find { |tnp| relation.first.start_with?(tnp) }
+          model_filename = "app/models/#{ActiveSupport::Inflector.singularize(relation.first)}.rb"
+          relation.last[:cols].each do |col, type|
             col_down = col.downcase
 
             if (is_possible_poly = ['character varying', 'text'].include?(type.first))
@@ -40,7 +52,7 @@ module Brick
               end
               is_possible_poly = false if col_down.length < 6 # Was it simply called "type" or something else really short?
               if is_possible_poly && !File.exist?(model_filename) # Make sure a model file isn't present
-                possible_polymorphics["#{v.first}.#{col_down}"] = "'#{v.first}.#{col[0..poly_type_cut_length]}'"
+                possible_polymorphics["#{relation.first}.#{col_down}"] = "'#{relation.first}.#{col[0..poly_type_cut_length]}'"
                 next
               end
             end
@@ -66,16 +78,24 @@ module Brick
               col_down = col_down[2..-1]
             end
             # This possible key not really a primary key and not yet used as a foreign key?
-            if is_possible && !(relation = relations.fetch(v.first, {}))[:pkey].first&.last&.include?(col) &&
-               !relations.fetch(v.first, {})[:fks]&.any? { |_k, v| v[:is_bt] && v[:fk] == col }
-              # Starting to look promising ... make sure a model file isn't present
-              if !File.exist?(model_filename)
-                if (relations.fetch(f_table = col_down, nil) ||
-                  relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)) &&
-                  s["#{v.first}.#{col_down}"] << "['#{v.first}', '#{col}', '#{f_table}']"
-                else
-                  resembles_fks["#{v.first}.#{col_down}"] << "#{v.first}.#{col}"
-                end
+            if is_possible && !relation.last[:pkey].first&.last&.include?(col) &&
+               !relation.last[:fks]&.any? { |_k, v| v[:is_bt] && v[:fk] == col } &&
+               # Starting to look promising ... make sure a model file isn't present
+               !File.exist?(model_filename)
+              if (
+                  (relations.fetch(f_table = col_down, nil) ||
+                   relations.fetch(f_table = ActiveSupport::Inflector.pluralize(col_down), nil)
+                  ) && s["#{relation.first}.#{col_down}"] << "['#{relation.first}', '#{col}', '#{f_table}']"
+                 ) ||
+                 (
+                  this_tnp && (full_col_down = this_tnp + col_down) &&
+                  (relations.fetch(f_table = full_col_down, nil) ||
+                   relations.fetch(f_table = ActiveSupport::Inflector.pluralize(full_col_down), nil)
+                  ) && s["#{relation.first}.#{full_col_down}"] << "['#{relation.first}', '#{col}', '#{f_table}']"
+                 )
+                # Found a possible_additional_reference (and set as the last action of the conditional check above)
+              else
+                resembles_fks["#{relation.first}.#{col_down}"] << "#{relation.first}.#{col}"
               end
             end
           end
@@ -183,7 +203,13 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # ::Brick.controllers_inherit_from = 'ApplicationController'
 
   # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
-  # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
+  #{
+    if tnps
+      "Brick.table_name_prefixes = #{tnps.inspect}"
+    else
+      "# Brick.table_name_prefixes = { 'nav_' => 'Navigation' }"
+    end
+  }
 
   # # COLUMN SEQUENCING AND INCLUSION / EXCLUSION
 
@@ -256,6 +282,10 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # # instead of \"user_profile\", then apply that as a third parameter like this:
   # Brick.has_ones = [['User', 'user_profile', 'profile']]
 
+  # # Automatically establish #accepts_nested_attributes_for logic on has_many and has_one associations.
+  # # This video to demonstrates how this works:  https://github.com/lorint/brick/assets/5301131/82ac4f6d-bc23-4a55-adab-bc754bcb0f26
+  # Brick.nested_attributes = { 'User' => ['profile', 'posts'] }
+
   # # We normally don't show the timestamp columns \"created_at\", \"updated_at\", and \"deleted_at\", and also do
   # # not consider them when finding associative tables to support an N:M association.  (That is, ones that can be a
   # # part of a has_many :through association.)  If you want to use different exclusion columns than our defaults

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.151
+  version: 1.0.153
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-08 00:00:00.000000000 Z
+date: 2023-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord