brick 1.0.152 → 1.0.154

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b4101e6f3437aaf0cb79eec97a94b9df6655d9db8a4773e761768556d2ec31f
-  data.tar.gz: 543bad78f1a359af9126373928789d868530b7ed09c17dbf18bf52a012a37763
+  metadata.gz: 647f34b463dc92515c7eb04331726a808b5ea69dd2bbd6ef99c9d6c769868565
+  data.tar.gz: 22ae7fa65845e65a7848f5cfff0fbb52a864b0161783c3f7d28cfb82ba1f88e5
 SHA512:
-  metadata.gz: 84d77e9a74428eea4e90f0a40b6e2a6dc824623a6b8975659698b4c79b73ec2ec5f5f26409c5d3d7f0c89c33e6c0aafb73a0c69b8cb3900654d10c528f3d4699
-  data.tar.gz: 556ad657abeb7a2368940a8b651ef85e6d3c410684e3ab7a088d741ea851e5c31b51bbe8f8baaa017231f56eb7fa177928782b68c6ee7b00c053d1267ac67a1f
+  metadata.gz: 84034f48010bd159804a19cb865a9cad04ba5efe89bb1e807a7031393d9a64a33d9ca9802f991565f4d73753df087d200099052dde59e4127c6b94370456ec09
+  data.tar.gz: 57b3cca20e566ef0d4ac72a45f24b025feea45421417b23cbe7cb683877ac228463f5f348f931a6024b9cdf750dde6aa6c49293e1ae1a596a70a0d8f3c128d6c

data/lib/brick/config.rb

@@ -230,6 +230,14 @@ module Brick
       @mutex.synchronize { @json_columns = cols }
     end
 
+    def sidescroll
+      @mutex.synchronize { @sidescroll ||= {} }
+    end
+
+    def sidescroll=(scroll)
+      @mutex.synchronize { @sidescroll = scroll }
+    end
+
     def model_descrips
       @mutex.synchronize { @model_descrips ||= {} }
     end

data/lib/brick/extensions.rb

@@ -1244,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
 
@@ -1475,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)
@@ -2225,7 +2238,7 @@ class Object
                   end
                 end
               end
-              if (upd_hash ||= upd_params).fetch(model.inheritance_column, nil).strip == ''
+              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)
@@ -2485,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

@@ -864,6 +864,10 @@ tr th {
   color: #fff;
   text-align: left;
 }
+.col-sticky {
+  position: sticky;
+  left: 0;
+}
 #headerTop tr th {
   position: relative;
 }
@@ -902,6 +906,10 @@ tr td.highlight {
   background-color: #B0B0FF;
 }
 
+table tr .col-sticky {
+  background-color: #28B898;
+}
+
 .show-field {
   background-color: #004998;
 }
@@ -916,6 +924,12 @@ table.shadow > tbody > tr {
 table tbody tr:nth-of-type(even) {
   background-color: #f3f3f3;
 }
+table tbody tr:nth-of-type(even) .col-sticky {
+  background-color: #fff;
+}
+table tbody tr:nth-of-type(odd) .col-sticky {
+  background-color: #f3f3f3;
+}
 
 table.shadow > tbody > tr:last-of-type {
   border-bottom: 2px solid #009879;
@@ -1080,18 +1094,30 @@ function setHeaderSizes() {
   // %%% Grab the TRs from headerTop, clear it out, do this stuff, add them back
   headerTop.innerHTML = \"\"; // %%% Would love to not have to clear it out like this every time!  (Currently doing this to support resize events.)
   var isEmpty = headerTop.childElementCount === 0;
+  var numFixed = parseInt(grid.getAttribute(\"x-num-frozen\")) || 0;
+  var fixedColLefts = [0];
+
   // Set up proper sizings of sticky column header
   var node;
   for (var j = 0; j < #{table_name}HtColumns.length; ++j) {
     var row = #{table_name}HtColumns[j];
     var tr = isEmpty ? document.createElement(\"TR\") : headerTop.childNodes[j];
     tr.innerHTML = row.innerHTML.trim();
+    var curLeft = 0.0;
     // Match up widths from the original column headers
     for (var i = 0; i < row.childNodes.length; ++i) {
       node = row.childNodes[i];
       if (node.nodeType === 1) {
         var th = tr.childNodes[i];
         th.style.minWidth = th.style.maxWidth = getComputedStyle(node).width;
+        // Add \"left: __px\" style to the fixed-width column THs
+        if (i <= numFixed) {
+          th.style.position = \"sticky\";
+          th.style.backgroundColor = \"#008061\";
+          th.style.zIndex = \"1\";
+          th.style.left = curLeft + \"px\";
+          fixedColLefts.push(curLeft += node.clientWidth);
+        }
         if (#{pk&.present? ? 'i > 0' : 'true'}) {
           // Add <span> at the end
           var span = document.createElement(\"SPAN\");
@@ -1108,6 +1134,12 @@ function setHeaderSizes() {
     headerCols = tr.childNodes;
     if (isEmpty) headerTop.appendChild(tr);
   }
+  // Add \"left: __px\" style to all fixed-width column TDs
+  [...grid.children[1].children].forEach(function (row) {
+    for (var j = 1; j <= numFixed; ++j) {
+      row.children[j].style.left = fixedColLefts[j] + 'px';
+    }
+  });
   grid.style.marginTop = \"-\" + getComputedStyle(headerTop).height;
   // console.log(\"end\");
 }
@@ -1686,7 +1718,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,9 +1,34 @@
 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
+
+    nfc = Brick.config.sidescroll.fetch(relation.table_name, nil)&.fetch(:num_frozen_columns, nil) ||
+          Brick.config.sidescroll.fetch(:num_frozen_columns, nil) ||
+          0
     out = "<table id=\"headerTop\"></table>
-<table id=\"#{relation.table_name.split('.').last}\" class=\"shadow\">
+<table id=\"#{relation.table_name.split('.').last}\" class=\"shadow\"#{ " x-num-frozen=\"#{nfc}\"" if nfc.positive? }>
   <thead><tr>"
     pk = (klass = relation.klass).primary_key || []
     pk = [pk] unless pk.is_a?(Array)
@@ -14,8 +39,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 +69,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 = {}
@@ -72,12 +98,13 @@ module Brick::Rails::FormTags
     #     (After restarting the server it worked fine again.)
     relation.each do |obj|
       out << "<tr>\n"
-      out << "<td>#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym,
+      out << "<td class=\"col-sticky\">#{link_to('⇛', send("#{klass._brick_index(:singular)}_path".to_sym,
                                       pk.map { |pk_part| obj.send(pk_part.to_sym) }), { class: 'big-arrow' })}</td>\n" if pk.present?
-      sequence.each do |col_name|
+      sequence.each_with_index do |col_name, idx|
         val = obj.attributes[col_name]
         bt = bts[col_name]
         out << '<td'
+        (classes ||= []) << 'col-sticky' if idx < nfc
         (classes ||= []) << 'dimmed' unless cols.key?(col_name) || (cust_col = cust_cols[col_name]) ||
                                             (col_name.is_a?(Symbol) && bts.key?(col_name)) # HOT
         (classes ||= []) << 'right' if val.is_a?(Numeric) && !bt
@@ -261,16 +288,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 +296,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 = 152
+    TINY = 154
 
     # 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?
@@ -494,6 +501,11 @@ module Brick
       Brick.config.json_columns = cols
     end
 
+    # @api public
+    def sidescroll=(scroll)
+      Brick.config.sidescroll = scroll
+    end
+
     # DSL templates for individual models to provide prettier descriptions of objects
     # @api public
     def model_descrips=(descrips)
@@ -1375,14 +1387,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
 
@@ -218,6 +244,14 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
   # Brick.column_sequence = { 'users' =>   { include: ['email', 'profile.firstname', 'profile.lastname'] },
   #                           'profile' => { exclude: ['birthdate'] } }
 
+  # # When rendering the grid on index pages, a default number of columns to keep as \"sticky\" so that they remain
+  # # at the left of the grid while scrolling.  By default this is 0 extra columns -- only the link to that
+  # # object's show / edit page is sticky.  And this would add one extra column in the mix:
+  # Brick.sidescroll = { num_frozen_columns: 1 }
+  # # As well if you would like to customise this for specific resources, that is possible:
+  # Brick.sidescroll = { num_frozen_columns: 0,
+  #                      'products' => { num_frozen_columns: 2 } }
+
   # # EXTRA FOREIGN KEYS AND OTHER HAS_MANY SETTINGS
 
   # # Additional table references which are used to create has_many / belongs_to associations inside auto-created

metadata

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