brick 1.0.246 → 1.0.247

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3410ae5fca9b12aa31007df9d3fac95a39f09eee58f4ffc2089bada97bde7793
-  data.tar.gz: 0da56c9311d8dd0ce2fd3a05039a6f85ca9910c64b303c25fc26f8d65fab512b
+  metadata.gz: baf36636026c4ecad5ff76ccdeea80604c6c9128f7065d7b546ab41cc4fccf1c
+  data.tar.gz: ec8c081354229eb5b4cdcd3112b24313468aaf731f856168cace28d3882e1f51
 SHA512:
-  metadata.gz: 7a2e821dfee25a5df265caf5700e25003cbc7cab88e439102fc949f5dfbba2f9f7b73803c98068d373ffbf12cab27dac3859c76a7772ea19bbaf4ffdbfbddbe6
-  data.tar.gz: 701d6d9e7d374cbe850806ce732f5b765c1ea3d051c111f316bcd29fdf45622d8999c04fa89ca058f13052670f56c77350fde24e00139ef40dc892b0c97ca896
+  metadata.gz: 3742d4d628c4f0ff18008f5dd965b3e49c545d24141cea917a0ba141cff7f3243b6f159e732f2e786b87f274e80237bcea2af74f17b9494345cf898e54e72928
+  data.tar.gz: 3aa5e54bc3b4af270e5b2342430e294920b151139af66ec5771b15a575377f7275f9c10e593d7c1d314e67d145fd9ffb0ae834b4f68a5d4c1afff8b22ecc404c

data/lib/brick/extensions.rb

@@ -105,13 +105,41 @@ module ActiveRecord
         col_names = columns_hash.keys
         # If it's a composite primary key then allow all the values through
         # TODO: Should disallow any autoincrement / SERIAL columns
-        if skip_id && (pk_as_array = _pk_as_array).length == 1
-          col_names -= _pk_as_array
+        if skip_id && (pk_as_array = _pk_as_array).length == 1 &&
+           [:string, :text].exclude?(columns_hash[pk_as_array.first]&.type)
+          col_names -= pk_as_array
         end
         hoa, hma, rtans = _activestorage_actiontext_fields
         col_names.map(&:to_sym) + hoa + hma.map { |as| { as => [] } } + rtans.values
       end
 
+      def _brick_set_wheres(params, join_array = nil)
+        is_distinct = nil
+        wheres = {}
+        params.each do |k, v|
+          k = k.to_s # Rails < 4.2 comes in as a symbol
+          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
+          case ks.length
+          when 1
+            next unless self.column_names.any?(where_col) || self._brick_get_fks.include?(where_col)
+          when 2
+            assoc_name = ks.first.to_sym
+            # Make sure it's a good association name and that the model has that column name
+            next unless self.reflect_on_association(assoc_name)&.klass&.column_names&.any?(where_col)
+
+            join_array&.[]=(assoc_name, nil) # Store this relation name in our special collection for .joins()
+            is_distinct = true
+          end
+          wheres[k] = v.is_a?(String) ? v.split(',') : v
+        end
+        [wheres, is_distinct]
+      end
+
       # Return three lists of fields for this model --
       # has_one_attached, has_many_attached, and has_rich_text
       def _activestorage_actiontext_fields
@@ -219,10 +247,17 @@ module ActiveRecord
         else
           # If there's no DSL yet specified, just try to find the first usable column on this model
           dsl = if table_exists?
-                  skip_columns = _brick_get_fks + (::Brick.config.metadata_columns || []) + [primary_key]
-                  if (descrip_col = columns.find { |c| c.type == :string && skip_columns.exclude?(c.name) })
+                  skip_columns = _brick_get_fks + (::Brick.config.metadata_columns || [])
+                  column_list = columns.dup
+                  pk_idx = column_list.index { |c| c.name == primary_key }
+                  if pk_idx
+                    pk_column = column_list.delete_at(pk_idx)
+                    # if the PK column is a string, put it at the end so it will get chosen as a last resort
+                    column_list << pk_column if [:string, :text].include?(columns_hash[primary_key]&.type)
+                  end
+                  if (descrip_col = column_list.find { |c| c.type == :string && skip_columns.exclude?(c.name) })
                     "[#{descrip_col.name}]"
-                  elsif (descrip_col = columns.find { |c| [:boolean, :binary, :xml].exclude?(c.type) && skip_columns.exclude?(c.name) })
+                  elsif (descrip_col = column_list.find { |c| [:boolean, :binary, :xml].exclude?(c.type) && skip_columns.exclude?(c.name) })
                     "[#{descrip_col.name}]"
                   else
                     "#{name} ##{_pk_as_array.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
@@ -689,32 +724,10 @@ module ActiveRecord
       # model early in case the user wants to do an ORDER BY based on any of that.
       model._brick_calculate_bts_hms(translations, join_array) if is_add_bts || is_add_hms
 
-      is_distinct = nil
-      wheres = {}
       params = params.to_unsafe_h unless params.is_a?(Hash)
       params.merge!(args[1]) if args[1]
-      params.each do |k, v|
-        k = k.to_s # Rails < 4.2 comes in as a symbol
-        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
-        case ks.length
-        when 1
-          next unless klass.column_names.any?(where_col) || klass._brick_get_fks.include?(where_col)
-        when 2
-          assoc_name = ks.first.to_sym
-          # Make sure it's a good association name and that the model has that column name
-          next unless klass.reflect_on_association(assoc_name)&.klass&.column_names&.any?(where_col)
-
-          join_array[assoc_name] = nil # Store this relation name in our special collection for .joins()
-          is_distinct = true
-          distinct!
-        end
-        wheres[k] = v.is_a?(String) ? v.split(',') : v
-      end
+      wheres, is_distinct = klass._brick_set_wheres(params, join_array)
+      distinct! if is_distinct
 
       # %%% Skip the metadata columns
       if selects.empty? # Default to all columns
@@ -1756,7 +1769,7 @@ class Object
       end
       full_name = if relation || schema_name.blank?
                     if singular_table_name != table_name.singularize && # %%% Try this with http://localhost:3000/brick/spree/property_translations
-                       (schema_module = ::Brick.config.table_name_prefixes.find { |k, v| table_name.start_with?(k) }&.last&.constantize)
+                       (schema_module = ::Brick.config.table_name_prefixes.find { |k, v| table_name.length > k&.length && table_name.start_with?(k) }&.last&.constantize)
                       "#{schema_module&.name}::#{inheritable_name || model_name}"
                     else
                       inheritable_name || model_name
@@ -1775,7 +1788,7 @@ class Object
                 ::Brick.config.exclude_tables.include?(matching)
 
       # Are they trying to use a pluralised class name such as "Employees" instead of "Employee"?
-      if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
+      if table_name == singular_table_name && model_name.pluralize == model_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
         # unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.camelize}::")
         #   puts "Warning: Class name for a model that references table \"#{matching
         #        }\" should be \"#{ActiveSupport::Inflector.singularize(inheritable_name || model_name)}\"."
@@ -2475,10 +2488,19 @@ class Object
 
             real_model = model.find_real_model(params)
 
+            # %%% Allow params to define which columns to use for order_by
+            # Overriding the default by providing a querystring param?
+            order_by = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
+
             if request.format == :csv # Asking for a template?
               require 'csv'
               exported_csv = CSV.generate(force_quotes: false) do |csv_out|
-                real_model.df_export(true, real_model.brick_import_template, false, wheres, order_by).each do |row|
+                export_args = [true, real_model.brick_import_template, false]
+                if real_model.method(:df_export).parameters.length > 3
+                  wheres, _is_distinct = real_model._brick_set_wheres(params)
+                  export_args += [wheres, order_by]
+                end
+                real_model.df_export(*export_args).each do |row|
                   row.each do |d|
                     row.each_with_index do |d, idx|
                       # "false" disallows HTML encoding the descriptions of binary content
@@ -2499,11 +2521,6 @@ class Object
             end
 
             # Normal (not swagger or CSV) request
-
-            # %%% Allow params to define which columns to use for order_by
-            # Overriding the default by providing a querystring param?
-            order_by = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
-
             ar_relation = ActiveRecord.version < Gem::Version.new('4') ? real_model.preload : real_model.all
             params['_brick_is_api'] = true if (is_api = request.format == :js || current_api_root)
             @_brick_params = ar_relation._brick_querying((selects ||= []), params: params, order_by: order_by,
@@ -2696,7 +2713,14 @@ class Object
               render json: { result: es_result }
             else
               real_model, real_singular_table_name = model.real_singular(params)
-              created_obj = model.send(:new, send(params_name_sym))
+              # If there are any foreign keys that are strings and we've received a blank value, set that to nil
+              internal_params = (ac_params = send(params_name_sym))&.send(:parameters)
+              real_model.reflect_on_all_associations.each do |a|
+                if a.belongs_to? && internal_params.key?(fk_name = a.foreign_key.to_s) && [:string, :text].include?((fk_col = real_model.columns_hash[fk_name])&.type)
+                  internal_params[fk_name] = nil if internal_params[fk_name].blank?
+                end
+              end
+              created_obj = model.send(:new, ac_params)
               if created_obj.respond_to?(inh_col = model.inheritance_column) && created_obj.send(inh_col) == ''
                 created_obj.send("#{inh_col}=", model.name)
               end
@@ -2846,14 +2870,14 @@ class Object
           code << "  def #{params_name}\n"
           require_txt = model.base_class.name.underscore.tr('/', '_')
           is_for_expects = ::ActiveSupport.version >= ::Gem::Version.new('8.0a')
-          permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields(true), is_for_expects)
+          permits = model._brick_find_permits(model, model._brick_all_fields(true), is_for_expects)
           if is_for_expects
-            code << "    params.expect(#{require_txt}: #{permits_txt})\n"
+            code << "    params.expect(#{require_txt}: #{permits})\n"
             self.define_method(params_name) do
               params.expect({ model.base_class.name.underscore.tr('/', '_').to_sym => permits })
             end
           else
-            code << "    params.require(:#{require_txt}).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
+            code << "    params.require(:#{require_txt}).permit(#{permits.map(&:inspect).join(', ')})\n"
             self.define_method(params_name) do
               params.require(model.base_class.name.underscore.tr('/', '_').to_sym).permit(permits)
             end

data/lib/brick/rails/engine.rb

@@ -950,7 +950,10 @@ if (window.brickFontFamily) {
                        when 'index'
                          if Object.const_defined?('DutyFree')
                            template_link = "
-  <%= link_to 'CSV', #{@_brick_model._brick_index}_path(format: :csv) %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
+  <%= csv_path = #{@_brick_model._brick_index}_path(format: :csv)
+      where_params = params.to_unsafe_h.each_with_object([]) { |v, s| s << \"#\{v.first}=#\{v[1]}\" if v.first.start_with?('__') }.join('&')
+      csv_path << \"?#\{where_params}\" unless where_params.blank?
+      link_to 'CSV', csv_path %> &nbsp; <a href=\"#\" id=\"sheetsLink\">Sheets</a>
   <div id=\"dropper\" contenteditable=\"true\"></div>
   <input type=\"button\" id=\"btnImport\" value=\"Import\">
 
@@ -1466,21 +1469,11 @@ if (description = rel&.fetch(:description, nil)) %>
 end
 %><%= link_to \"(See all #\{model_name.pluralize})\", see_all_path, { class: '__brick' } %>
 #{::Brick::Rails.erd_markup(@_brick_model, prefix) if @_brick_model}
-<% if obj
-     # path_options = [obj.#{pk}]
-     # path_options << { '_brick_schema':  } if
-     options = {}
-     options[:url] = if obj.new_record?
-                       link_to_brick(obj.class, path_only: true) # Properly supports STI, but only works for :new
-                     else
-                       path_helper = obj.new_record? ? #{model_name}._brick_index : #{model_name}._brick_index(:singular)
-                       options[:url] = send(\"#\{path_helper}_path\".to_sym, obj) if ::Brick.config.path_prefix || (path_helper != obj.class.table_name)
-                     end
-%>
+<% if obj %>
   <br><br>
 
 <%= # Write out the mega-form
-    brick_form_for(obj, options, #{model_name}, bts, #{pk.inspect}) %>
+    brick_form_with(model: obj, bts: bts, pk: #{pk.inspect}) %>
 
 #{unless args.first == 'new'
   # Was:  confirm_are_you_sure = ActionView.version < ::Gem::Version.new('7.0') ? "data: { confirm: \"Delete #\{model_name} -- Are you sure?\" }" : "form: { data: { turbo_confirm: \"Delete #\{model_name} -- Are you sure?\" } }"

data/lib/brick/rails/form_builder.rb

@@ -9,18 +9,19 @@ module Brick::Rails::FormBuilder
   def brick_field(method, html_options = {}, val = nil, col = nil,
                   bt = nil, bt_class = nil, bt_name = nil, bt_pair = nil)
     model = self.object.class
-    col ||= model.columns_hash[method]
+    col ||= model.columns_hash[method.to_s]
     out = +'<table><tr><td>'
     html_options[:class] = 'dimmed' unless val
     is_revert = true
     template = instance_variable_get(:@template)
+    method_sym = method.to_sym
     if bt
       bt_class ||= bt[1].first.first
       bt_name ||= bt[1].map { |x| x.first.name }.join('/')
       bt_pair ||= bt[1].first
 
       html_options[:prompt] = "Select #{bt_name}"
-      out << self.select(method.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options)
+      out << self.select(method_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options)
       bt_obj = nil
       begin
         bt_obj = bt_class&.find_by(bt_pair[1] => val)
@@ -38,8 +39,8 @@ module Brick::Rails::FormBuilder
                   "<span class=\"orphan\">Orphaned ID: #{val}</span>".html_safe
                 end
       out << bt_link if bt_link
-    elsif model._brick_monetized_attributes&.include?(method)
-      out << self.text_field(method.to_sym, html_options.merge({ value: Money.new(val.to_i).format }))
+    elsif model._brick_monetized_attributes&.include?(method.to_s)
+      out << self.text_field(method_sym, html_options.merge({ value: Money.new(val.to_i).format }))
     else
       col_type = if model.json_column?(col) || val.is_a?(Array)
                    :json
@@ -61,40 +62,40 @@ module Brick::Rails::FormBuilder
             out << "<img src=\"#{url}\" title=\"#{val}\">"
           elsif model.respond_to?(:enumerized_attributes) && (opts = (attr = model.enumerized_attributes[method])&.options).present?
             enum_html_options = attr.kind_of?(Enumerize::Multiple) ? html_options.merge({ multiple: true, size: opts.length + 1 }) : html_options
-            out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, enum_html_options)
+            out << self.select(method_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, enum_html_options)
           else
             spit_out_text_field = true
           end
         elsif col_type == :enum
           if col.respond_to?(:limit) && col.limit.present?
-            out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + col.limit, { value: val.to_s || '^^^brick_NULL^^^' }, html_options)
+            out << self.select(method_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + col.limit, { value: val.to_s || '^^^brick_NULL^^^' }, html_options)
           else
             spit_out_text_field = true
           end
         else
           template.instance_variable_set(:@_text_fields_present, true)
-          out << self.hidden_field(method.to_sym, html_options)
+          out << self.hidden_field(method_sym, html_options)
           out << "<trix-editor input=\"#{self.field_id(method)}\"></trix-editor>"
         end
         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)
+          out << self.text_field(method_sym, html_options)
         end
         when :boolean
-        out << self.check_box(method.to_sym)
+        out << self.check_box(method_sym)
       when :integer, :decimal, :float
-        if model.respond_to?(:attribute_types) && (enum_type = model.attribute_types[method]).is_a?(ActiveRecord::Enum::EnumType)
+        if model.respond_to?(:attribute_types) && (enum_type = model.attribute_types[method.to_s]).is_a?(ActiveRecord::Enum::EnumType)
           opts = enum_type.send(:mapping)&.each_with_object([]) { |v, s| s << [v.first, v.first] } || []
-          out << self.select(method.to_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, options)
+          out << self.select(method_sym, [["(No #{method} chosen)", '^^^brick_NULL^^^']] + opts, { value: val || '^^^brick_NULL^^^' }, options)
         else
           digit_pattern = col_type == :integer ? '(?:-|)\d*' : '(?:-|)\d*(?:\.\d*|)'
-          # Used to do this for float / decimal:  self.number_field method.to_sym
-          out << self.text_field(method.to_sym, { pattern: digit_pattern, class: 'check-validity' })
+          # Used to do this for float / decimal:  self.number_field method_sym
+          out << self.text_field(method_sym, { pattern: digit_pattern, class: 'check-validity' })
         end
       when *DT_PICKERS.keys
         template.instance_variable_set(:@_date_fields_present, true)
-        out << self.text_field(method.to_sym, { class: DT_PICKERS[col_type] })
+        out << self.text_field(method_sym, { class: DT_PICKERS[col_type] })
       when :uuid
         is_revert = false
         # Postgres naturally uses the +uuid_generate_v4()+ function from the uuid-ossp extension
@@ -146,7 +147,7 @@ module Brick::Rails::FormBuilder
         end
         out << self.hidden_field("_brick_attached_#{method}", value: existing.join(',')) unless existing.blank?
         # Render a "Choose File(s)" input element
-        args = [method.to_sym]
+        args = [method_sym]
         args << { multiple: true } if col&.type == :files
         out << self.file_field(*args)
       when :primary_key
@@ -163,7 +164,7 @@ module Brick::Rails::FormBuilder
         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_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
@@ -177,6 +178,7 @@ module Brick::Rails::FormBuilder
     end
     out << "</td></tr></table>
 "
+    @_brick&.fetch(:fields_rendered, nil)&.<< method.to_s # Track that we've rendered this one
     out.html_safe
   end # brick_field
 end

data/lib/brick/rails/form_tags.rb

@@ -30,7 +30,7 @@ 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)) ||
+              (pk.include?(col_name) && ([:string, :text].exclude?(col.type) || col_name == 'airtable_id') && !bts&.key?(col_name)) ||
               ::Brick.config.metadata_columns.include?(col_name) || poly_cols&.include?(col_name)
 
       s << col_name
@@ -252,25 +252,52 @@ module Brick::Rails::FormTags
 
   # -----------------------------
   # Our mega show/new/update form
-  def brick_form_for(obj, options = {}, model = obj.class, bts = {}, pk = (obj.class.primary_key || []))
+  def brick_form_with(**options, &block)
+    obj = options.delete(:model) || instance_variable_get("@#{obj_name = controller_name.singularize}".to_sym)
+    unless obj
+      puts "WARNING:  Could not find #{obj_name} object"
+      return
+    end
+
+    model = obj.class
+    bts = options.delete(:bts) || {}
+    pk = options.delete(:pk) || model.primary_key || []
     pk = [pk] unless pk.is_a?(Array)
     pk.map!(&:to_s)
+    brick_stuff = { fields_rendered: (fields_rendered = []), bts: bts, pk: pk }
+
+    # options[:model] = obj.becomes(model.base_class) unless options.include?(:model)
+    unless options.include?(:url)
+      options[:url] = if obj.new_record?
+                        link_to_brick(obj.class, path_only: true) # Properly supports STI, but only works for :new
+                      else
+                        path_helper = obj.new_record? ? model._brick_index : model._brick_index(:singular)
+                        send("#{path_helper}_path".to_sym, obj) if ::Brick.config.path_prefix || (path_helper != obj.class.table_name)
+                      end
+    end
+
+    # We call into the older #form_for in order to have compatibility with Rails < 5.1
     form_for(obj.becomes(model.base_class), options) do |f|
-      out = +'<table class="shadow">'
-      has_fields = false
+      out = +''
+      out << '<table class="shadow">'
+      f.instance_variable_set(:@_brick, brick_stuff)
+      has_fields = has_updatable_fields = nil
       # If it's a new record, set any default polymorphic types
-      bts&.each do |_k, v|
+      bts.each do |_k, v|
         if v[2]
           obj.send("#{model.brick_foreign_type(v.first)}=", v[1].first&.first&.name)
         end
       end if obj.new_record?
       hoa, hma, rtans = model._activestorage_actiontext_fields
-      (model.column_names + hoa + hma + rtans.keys).each do |k|
+
+      block.call(f) if block_given?
+
+      ((model.column_names + hoa + hma + rtans.keys) - fields_rendered).each do |k|
         pk_pos = (pk.index(k)&.+ 1)
-        next if (pk_pos && pk.length == 1 && !bts.key?(k)) ||
+        col = model.columns_hash[k]
+        next if (pk_pos && pk.length == 1 && !bts.key?(k) && [:string, :text].exclude?(col.type)) ||
                 ::Brick.config.metadata_columns.include?(k)
 
-        col = model.columns_hash[k]
         if !col
           kwargs = if hoa.include?(k) # has_one_attached
                      { sql_type: 'binary', type: :file }
@@ -291,7 +318,7 @@ module Brick::Rails::FormTags
         val = obj.attributes[k]
         out << "
   <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}\"" 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
@@ -334,35 +361,38 @@ module Brick::Rails::FormTags
         else
           out << model.human_attribute_name(k, { default: k })
         end
-        out << " (PK #{pk_pos})" if pk_pos
+        out << " (PK&nbsp;#{pk_pos})" if pk_pos
         out << "
     </th>
     <td>
         "
-        if pk_pos
+        if pk_pos &&
+           # Allow new records to have a text-based primary key to be entered
+           (!obj.new_record? || [:string, :text].exclude?(col.type))
           out << val.to_s
         else
+          has_updatable_fields = true
           out << f.brick_field(k, html_options = {}, val, col, bt, bt_class, bt_name, bt_pair)
         end
         out << "
     </td>
   </tr>"
       end
-      if has_fields
+      if has_updatable_fields
         out << "<tr><td colspan=\"2\">#{f.submit({ class: 'update' })}</td></tr>"
-      else
+      elsif !has_fields
         out << '<tr><td colspan="2">(No displayable fields)</td></tr>'
       end
       out << '</table>'
       if model.name == 'ActiveStorage::Attachment'
         begin
-          out << ::Brick::Rails.display_binary(obj&.blob&.download, 500_000)&.html_safe
+          out << ::Brick::Rails.display_binary(obj&.blob&.download, 500_000)
         rescue
         end
       end
-      out.html_safe
-    end
-  end # brick_form_for
+      output_buffer << out.html_safe
+    end # form_for
+  end # brick_form_with
 
   # ------------------------------------------
   # Our cool N:M checkbox constellation editor
@@ -413,7 +443,7 @@ module Brick::Rails::FormTags
     end
     out << "  </tbody>
 </table>
-<script<%= @_request.env['_brick_nonce'] %>>
+<script#{@_request.env['_brick_nonce']}>
   var constellation = document.getElementById(\"#{table_name}\");
   var nextSib,
       _this;
@@ -480,7 +510,6 @@ module Brick::Rails::FormTags
     out << "  </tbody>
 </table>
 "
-
     out.html_safe
   end # brick_bezier
 
@@ -537,7 +566,7 @@ module Brick::Rails::FormTags
   </div>
 </div>
 "
-    out
+    out.html_safe
   end # brick_header
 
   # All the standard CSS with teal colouration for use with Brick
@@ -547,6 +576,8 @@ module Brick::Rails::FormTags
 
   # -----------------------------------------------------------------------------------------------
   def set_grid_javascript(klass, pk, show_new_button = nil, row_count = nil, total_row_count = nil)
+    camel_name = klass.name.split('::').last
+    camel_name[0].downcase!
     table_name = klass.table_name.split('.').last
 
     # Javascript for brick_grid and brick_constellation
@@ -556,13 +587,13 @@ module Brick::Rails::FormTags
 // Plunk the row count in now that we know it
 var rowCount = document.getElementById(\"rowCount\");
 if (rowCount) rowCount.innerHTML = \"#{pluralize(row_count, "row")}#{total_row_count} &nbsp;\";
-var #{table_name}HtColumns;
+var #{camel_name}HtColumns;
 " unless row_count.nil?
 
     grid_scripts << "
 // Snag first TR for sticky header
 var grid = document.getElementById(\"#{table_name}\");
-#{table_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
+#{camel_name}HtColumns = grid && [grid.getElementsByTagName(\"TR\")[0]];
 var headerTop = document.getElementById(\"headerTop\");
 var headerCols;
 if (grid) {
@@ -615,8 +646,8 @@ function setHeaderSizes() {
 
   // 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];
+  for (var j = 0; j < #{camel_name}HtColumns.length; ++j) {
+    var row = #{camel_name}HtColumns[j];
     var tr = isEmpty ? document.createElement(\"TR\") : headerTop.childNodes[j];
     tr.innerHTML = row.innerHTML.trim();
     var curLeft = 0.0;

data/lib/brick/rails.rb

@@ -6,7 +6,7 @@ require 'brick/rails/engine'
 module ::Brick::Rails
   class << self
     # Low-level way to render read-only data for a field based on its data type.
-    # Used by both brick_grid and brick_form_for (which gets down to this low-level
+    # Used by both brick_grid and brick_form_with (which gets down to this low-level
     # implementation from brick_field).
     def display_value(col_type, val, lat_lng = nil)
       is_mssql_geography = nil

data/lib/brick/reflect_tables.rb

@@ -143,7 +143,7 @@ module Brick
               ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
             else
               puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
-              if ::Brick.db_schemas.key?(::Brick.apartment_default_tenant)
+              if Object.const_defined?('Apartment') && ::Brick.db_schemas.key?(::Brick.apartment_default_tenant)
                 ::Brick.default_schema = schema = ::Brick.apartment_default_tenant
               end
             end
@@ -214,6 +214,7 @@ module Brick
             cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name), r['is_nullable'] == 'NO']
             # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
             relation[:col_descrips][col_name] = r['column_description'] if r['column_description']
+            relation[:col_order] << col_name
           end
         else # MySQL2, OracleEnhanced, and MSSQL act a little differently, bringing back an array for each row
           schema_and_tables = case ActiveRecord::Base.connection.adapter_name
@@ -269,6 +270,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
             # 'data_type', 'max_length', measure, 'is_nullable'
             cols[col_name] = [r[4], r[5], measures&.include?(col_name), r[8] == 'NO']
             # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
+            relation[:col_order] << col_name
           end
         end
 
@@ -443,14 +445,18 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         loop do
           klass = Object
           proposed_name_parts.each do |part|
-            if klass.const_defined?(part) && klass.name != part
-              begin
+            begin
+              if klass.const_defined?(part) && klass.name != part
                 klass = klass.const_get(part)
-              rescue NoMethodError => e
+              else
                 klass = nil
                 break
               end
-            else
+            rescue NoMethodError => e
+              klass = nil
+              break
+            rescue NameError => e
+              puts "WARNING:  Unable to automatically generate a class for the table named #{part}.\n  In the brick.rb initializer file you can add the line \"::Brick.table_name_prefixes = { '#{part}' => '::YourModelName' }\" in order to specify a usable class name for this object."
               klass = nil
               break
             end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -162,7 +162,7 @@ module Brick
                                   (existing = @relations.find { |_k, v| v.fetch(:db_name, nil) == db_name })
                                  existing.last
                                else
-                                 Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = {} } }.tap do |h|
+                                 Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = (k == :col_order ? [] : {}) } }.tap do |h|
                                    h[:db_name] = db_name if db_name
                                  end
                                end

data/lib/generators/brick/airtable_api_caller.rb

@@ -5,7 +5,7 @@ module Brick
     class << self
       include FancyGets
 
-      def pick_tables(usage = :migrations)
+      def pick_tables(is_airtable_id, usage = :migrations)
         puts "In order to reference Airtable data you will need a Personal Access Token (PAT) which can be generated by referencing this URL:
   https://airtable.com/create/tokens
 You need only #{usage == :migrations ? 'this scope:' : "these three scopes:
@@ -19,6 +19,10 @@ Please provide your Airtable PAT:"
         require 'net/http'
         # Generate a list of bases that can be chosen
         bases = https_get('https://api.airtable.com/v0/meta/bases', pat)
+        if (error = bases.fetch('error', nil))
+          puts error.fetch('message', nil) || 'Error'
+          return
+        end
         base = gets_list(bases.fetch('bases', nil)&.map { |z| AirtableTable.new(z['id'], z['name']) })
         puts
         # Generate a list of tables that can be chosen
@@ -35,10 +39,11 @@ Please provide your Airtable PAT:"
         # Build out a '::Brick.relations' hash that represents this Airtable schema
         fks = []
         associatives = {}
-        relations = chosen.each_with_object({}) do |table, s|
+        relations = chosen.each_with_object({base_name: base.name}) do |table, s|
                       tbl_name = sane_table_name(table.name)
                       # Build out columns and foreign keys
                       cols = {}
+                      col_order = []
                       table.fields.each do |col|
                         col_name = sane_name(col['name'])
                         # This is like a has_many or has_many through
@@ -48,7 +53,8 @@ Please provide your Airtable PAT:"
                                           chosen.find { |t| t.id == col['options']['linkedTableId'] }&.name
                                         ))
                             if col['options']['prefersSingleRecordLink'] # 1:M
-                              fks << [frn_tbl, "#{col_name}_id", tbl_name, col_name]
+                              fks << [frn_tbl, (fk_col_name = "#{col_name}_id"), tbl_name, col_name]
+                              col_order << fk_col_name
                             else # N:M
                               # Queue up to build associative table with two foreign keys
                               camelized = (assoc_name = "#{tbl_name}_#{col_name}_#{frn_tbl}").camelize
@@ -64,17 +70,17 @@ Please provide your Airtable PAT:"
                         else
                           # puts col['type']
                           dt = case col['type']
-                          when 'singleLineText', 'url', 'email', 'singleSelect'
+                          when 'singleLineText', 'url', 'email', 'singleSelect', 'phoneNumber'
                             'string'
                           when 'multilineText'
                             'text'
                           when 'number', 'currency'
-                            'decimal'
+                            col['options']['precision'] == 0 ? 'integer' : 'decimal'
                           when 'checkbox'
                             'boolean'
                           when 'date'
                             'date'
-                          when 'multipleSelects'
+                          when 'multipleSelects', 'singleCollaborator'
                             # Sqlite3 can do json
                             'json'
                           when 'formula', 'count', 'rollup', 'multipleAttachments'
@@ -83,13 +89,21 @@ Please provide your Airtable PAT:"
                           #   binding.pry
                           end
                           cols[col_name] = [dt, nil, true, false] # true is the col[:nillable]
+                          col_order << col_name
                         end
                       end
                       # Put it all into a relation entry, named the same as the table
-                      pkey = table.fields.find { |f| f['id'] == table.primary_key }['name']
+                      pkey = if is_airtable_id
+                               cols['airtable_id'] = ['string', nil, true, false]
+                               'airtable_id'
+                             else
+                               table.fields.find { |f| f['id'] == table.primary_key }['name']
+                             end
+
                       s[tbl_name] = {
                         pkey: { "#{tbl_name}_pkey" => [sane_name(pkey)] },
                         cols: cols,
+                        col_order: col_order,
                         fks: {},
                         airtable_table: table
                       }

data/lib/generators/brick/airtable_migrations_generator.rb

@@ -15,9 +15,10 @@ module Brick
     def airtable_migrations
       mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationsBuilder.check_folder
       return unless mig_path &&
-                    (relations = ::Brick::AirtableApiCaller.pick_tables)
+                    (relations = ::Brick::AirtableApiCaller.pick_tables(!ENV['OMIT_AIRTABLE_ID']))
 
-      ::Brick::MigrationsBuilder.generate_migrations(relations.keys, mig_path, is_insert_versions, is_delete_versions, relations,
+      chosen = relations.keys.reject { |k| k.is_a?(Symbol) }
+      ::Brick::MigrationsBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations,
                                                      do_fks_last: 'Separate', do_schema_migrations: false)
     end
   end

data/lib/generators/brick/airtable_seeds_generator.rb

@@ -11,7 +11,7 @@ module Brick
     desc 'Auto-generates a seeds file from existing data in an Airtable "base".'
 
     def airtable_seeds
-      return unless (relations = ::Brick::AirtableApiCaller.pick_tables(:seeds))
+      return unless (relations = ::Brick::AirtableApiCaller.pick_tables(!ENV['OMIT_AIRTABLE_ID'], :seeds))
 
       ::Brick::SeedsBuilder.generate_seeds(relations)
     end

data/lib/generators/brick/install_generator.rb

@@ -43,7 +43,7 @@ module Brick
           relation.last[:cols].each do |col, type|
             col_down = col.downcase
 
-            if (is_possible_poly = ['character varying', 'text'].include?(type.first))
+            if (is_possible_poly = ['character varying', 'varchar', 'text', 'VARCHAR2'].include?(type.first))
               if col_down.end_with?('_type')
                 poly_type_cut_length = -6
                 col_down = col_down[0..-6]

data/lib/generators/brick/migrations_builder.rb

@@ -119,7 +119,8 @@ module Brick
         stuck = {}
         indexes = {} # Track index names to make sure things are unique
         built_schemas = {} # Track all built schemas so we can place an appropriate drop_schema command only in the first
-                          # migration in which that schema is referenced, thereby allowing rollbacks to function properly.
+                           # migration in which that schema is referenced, thereby allowing rollbacks to function properly.
+        is_airtable = nil
         versions_to_create = [] # Resulting versions to be used when updating the schema_migrations table
         # Start by making migrations for fringe tables (those with no foreign keys).
         # Continue layer by layer, creating migrations for tables that reference ones already done, until
@@ -148,8 +149,9 @@ module Brick
             mig = gen_migration_columns(relations, tbl, (tbl_parts = tbl.split('.')), (add_fks = []), built_schemas, mig_path, current_mig_time,
                                         key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
             after_fks.concat(add_fks) if do_fks_last
-            current_mig_time[0] += 1.minute
-            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, separator, relations[tbl])}", current_mig_time, ar_version, mig)
+            increment_time(mig_path, current_mig_time)
+            is_airtable ||= (relation = relations[tbl])&.fetch(:airtable_table, nil)
+            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, separator, relation, true)}", current_mig_time, ar_version, mig)
           end
           done.concat(fringe)
           chosen -= done
@@ -161,15 +163,15 @@ module Brick
             mig = gen_migration_columns(relations, tbl, (tbl_parts = tbl.split('.')), (add_fks = []), built_schemas, mig_path, current_mig_time,
                                         key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
             after_fks.concat(add_fks)
-            current_mig_time[0] += 1.minute
+            increment_time(mig_path, current_mig_time)
             versions_to_create << migration_file_write(mig_path, "create_#{
-              ::Brick._brick_index(tbl, :migration, separator, relations[tbl])
+              ::Brick._brick_index(tbl, :migration, separator, relations[tbl], true)
             }", current_mig_time, ar_version, mig)
           end
           done.concat(chosen)
           chosen.clear
 
-          case do_fks_last
+          case after_fks.present? && do_fks_last
           when 'Separate' # Add a final migration to create all the foreign keys
             mig = +"  def change\n"
             after_fks.each do |add_fk|
@@ -201,9 +203,10 @@ module Brick
               'rb'
             end
             mig << +"  end\n"
-            current_mig_time[0] += 1.minute
-            versions_to_create << migration_file_write(mig_path, "create_brick_fks.#{fks_extension}", current_mig_time, ar_version, mig)
-            puts "Have written out a final migration called 'create_brick_fks.#{fks_extension}' which creates #{after_fks.length} foreign keys."
+            increment_time(mig_path, current_mig_time)
+            base_name = "_#{relations[:base_name]&.tr(' ', '')&.underscore}" if relations[:base_name]
+            versions_to_create << migration_file_write(mig_path, "create_brick_fks#{base_name}.#{fks_extension}", current_mig_time, ar_version, mig)
+            puts "Have written out a final migration called 'create_brick_fks#{base_name}.#{fks_extension}' which creates #{after_fks.length} foreign keys."
             if fks_extension == 'rbx'
               puts "  This file extension (.rbx) will cause it not to run yet when you do a 'rails db:migrate'.
   The idea here is to do all data loading first, and then rename that migration file back
@@ -247,7 +250,7 @@ module Brick
             ".  Here's the top 5 blockers" if stuck_sorted.length > 5
           }:"
           pp stuck_sorted[0..4]
-        elsif do_schema_migrations # Successful, and now we can update the schema_migrations table accordingly
+        elsif do_schema_migrations && !is_airtable # Successful, and now we can update the schema_migrations table accordingly
           smtn = ::Brick._schema_migrations_table_name
           if ActiveRecord::Migration.table_exists?(smtn)
             # Remove to_delete - to_create
@@ -298,7 +301,7 @@ module Brick
                  end
         unless schema.blank? || built_schemas.key?(schema)
           mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
-          current_mig_time[0] += 1.minute
+          increment_time(mig_path, current_mig_time)
           versions_to_create << migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time, ar_version, mig)
           built_schemas[schema] = nil
         end
@@ -352,7 +355,8 @@ module Brick
         mig = +"  def change\n    return unless reverting? || !table_exists?(#{tbl_code})\n\n"
         mig << "    create_table #{tbl_code}#{id_option} do |t|\n"
         possible_ts = [] # Track possible generic timestamps
-        relation[:cols].each do |col, col_type|
+        (relation.key?(:col_order) && relation[:col_order].present? && relation[:col_order].map { |col_name| [col_name, relation[:cols][col_name]] } ||
+         relation[:cols]).each do |col, col_type|
           sql_type = SQL_TYPES[col_type.first] || SQL_TYPES[col_type[0..1]] ||
                      SQL_TYPES.find { |r| r.first.is_a?(Regexp) && col_type.first =~ r.first }&.last ||
                      col_type.first
@@ -449,7 +453,16 @@ module Brick
         "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
       end
 
+      def increment_time(mig_path, current_mig_time)
+        loop do
+          current_mig_time[0] += 1.minute
+          break if Dir.glob("#{mig_path}/#{current_mig_time.first.strftime('%Y%m%d%H%M00')}_*.*").empty?
+
+        end
+      end
+
       def migration_file_write(mig_path, name, current_mig_time, ar_version, mig)
+        name.gsub!(/[^a-zA-Z0-9_\.\p{L}\p{N}]/, 'x') # Strip out any weird unicode characters
         File.open("#{mig_path}/#{version = current_mig_time.first.strftime('%Y%m%d%H%M00')}_#{name}#{'.rb' unless name.index('.')}", "w") do |f|
           f.write "class #{name.split('.').first.camelize} < ActiveRecord::Migration#{ar_version}\n"
           f.write mig

data/lib/generators/brick/seeds_builder.rb

@@ -13,9 +13,10 @@ module Brick
       end
 
       def generate_seeds(relations = nil)
+        action = 'Overwrite'
         if File.exist?((seed_file_path = "#{::Rails.root}/db/seed") + 's.rb')
-          puts "WARNING: seeds file #{seed_file_path}s.rb appears to already be present.\nOverwrite?"
-          return unless gets_list(list: ['No', 'Yes']) == 'Yes'
+          puts "WARNING: seeds file #{seed_file_path}s.rb appears to already be present.\nAppend or Overwrite?"
+          return if (action = gets_list(list: ['Cancel', 'Append', 'Overwrite'])) == 'Cancel'
 
           puts "\n"
         end
@@ -24,7 +25,7 @@ module Brick
           is_airtable = true # So far the only thing that feeds us relations is Airtable
           require 'generators/brick/airtable_api_caller'
           # include ::Brick::MigrationsBuilder
-          chosen = relations.map { |k, v| SeedModel.new(k, nil, false, v[:airtable_table]) }
+          chosen = relations.each_with_object([]) { |v, s| s << SeedModel.new(v.first, nil, false, v.last[:airtable_table]) unless v.first.is_a?(Symbol) }
         else
           ::Brick.mode = :on
           ActiveRecord::Base.establish_connection
@@ -57,11 +58,14 @@ module Brick
           end
         end
         batch_num = 1
-        seeds_file = File.open("#{seed_file_path}s.rb", 'w')
+        seeds_file = File.open("#{seed_file_path}s.rb", action == 'Overwrite' ? 'w' : 'a+')
+        seeds_file.write("\n") if action == 'Append'
         seeds_len = lines_len = 0
         seeds_file.write('# Seeds file for ')
         seed_rows = nil
-        if (arbc = ActiveRecord::Base.connection).respond_to?(:current_database) # SQLite3 can't do this!
+        if is_airtable
+          seeds_file.write("Airtable Base \"#{relations[:base_name]}\":\n")
+        elsif (arbc = ActiveRecord::Base.connection).respond_to?(:current_database) # SQLite3 can't do this!
           seeds_file.write("#{arbc.current_database}:\n")
         elsif (filename = arbc.instance_variable_get(:@connection_parameters)&.fetch(:database, nil))
           seeds_file.write("#{filename}:\n")
@@ -146,19 +150,38 @@ module Brick
 
             has_rows = false
             is_empty = true
-            klass_name = is_airtable ? ::Brick::AirtableApiCaller.sane_table_name(relation[:airtable_table]&.name)&.singularize&.camelize : klass.name
-            # Pull the records
-            collection = if is_airtable
-              if (airtable_table = relation[:airtable_table])
-                ::Brick::AirtableApiCaller.https_get("https://api.airtable.com/v0/#{airtable_table.base_id}/#{airtable_table.id}").fetch('records', nil)
-              end
-            else
-              # Must convert to a symbol when doing ORDER BY due to this ActiveRecord nuance:
-              # https://github.com/rails/rails/issues/2601
-              klass.order(*pkey_cols.map(&:to_sym)) unless relation[:pkey].empty?
-            end
+            collection = nil
+            klass_name = if is_airtable
+                           airtable_table = relation[:airtable_table]
+                           ::Brick.config.table_name_prefixes&.fetch(tbl, nil) ||
+                             tbl.singularize.camelize
+                         else
+                           # Must convert to a symbol when doing ORDER BY due to this ActiveRecord nuance:
+                           # https://github.com/rails/rails/issues/2601
+                           collection = klass.order(*pkey_cols.map(&:to_sym)).enum_for unless relation[:pkey].empty?
+                           klass.name
+                         end
             seed_rows = +''
-            collection&.each do |obj|
+            airtable_idx = offset = nil
+            while collection || airtable_table do
+              obj = if is_airtable
+                if collection.nil? || (airtable_idx += 1) >= collection.length
+                  break if collection && !offset
+
+                  offset_param = "?offset=#{offset}" if offset
+                  result = ::Brick::AirtableApiCaller.https_get("https://api.airtable.com/v0/#{airtable_table.base_id}/#{airtable_table.id}#{offset_param}")
+                  offset = result.fetch('offset', nil)
+                  collection = result.fetch('records', nil)
+                  airtable_idx = 0
+                end
+                collection[airtable_idx]
+              else
+                begin
+                  collection.next
+                rescue StopIteration
+                  break
+                end
+              end
               if is_airtable
                 fields = obj['fields'].each_with_object({}) do |field, s|
                   if relation[:cols].keys.include?(col_name = ::Brick::AirtableApiCaller.sane_name(field.first))
@@ -178,7 +201,7 @@ module Brick
                     end
                   end
                 end
-                objects = relation[:airtable_table].objects
+                objects = airtable_table.objects
                 obj = objects[airtable_id = obj['id']] = AirtableObject.new(seed_model, obj['fields'], obj['createdTime'])
               end
               unless has_rows
@@ -204,7 +227,12 @@ module Brick
                 # Used to be:  obj.send(col)
                 # (and with that it was possible to raise ActiveRecord::Encryption::Errors::Configuration...)
                 #  %%% should test further and see if that is possible with this code!)
-                if (val = obj.attributes_before_type_cast[col])
+                val = if is_airtable && col == 'airtable_id'
+                        pk_val
+                      else
+                        obj.attributes_before_type_cast[col]
+                      end
+                if val
                   if (val.is_a?(Time) || val.is_a?(Date))
                     val = val.to_s
                   elsif val.is_a?(Numeric)
@@ -283,28 +311,42 @@ end\n"
               end
               seed_rows = +''
             end
-            unless has_rows || klass_name.nil?
+            unless has_rows || (is_airtable && !airtable_table)
               seeds_file.write("  # (Skipping #{klass_name} as it has no rows)\n")
             end
           end
           done.concat(fringe)
           chosen -= done
         end
-        airtable_assocs_done = {}
-        airtable_assoc_recids.each do |table_name, assoc_pairs| # N:M links
-          # Make note of any other tables which have exactly duplicated data
-          dupes = airtable_assocs_done.select do |dupe_table, dupe_pairs|
-            dupe_table != table_name && assoc_pairs.length > 0 && assoc_pairs.length == dupe_pairs.length &&
-            dupe_pairs.all? { |pair_name, _v3| assoc_pairs.keys.include?(pair_name) }
+
+        if airtable_assoc_recids.present?
+          seed_rows << "\n# Seeding #{airtable_assoc_recids.count} sets of Airtable associations:\n"
+          airtable_assocs_done = {}
+          dupe_list = []
+          airtable_assoc_recids.each do |table_name, assoc_pairs| # N:M links
+            # Make note of any other tables which have exactly duplicated data
+            dupes = airtable_assocs_done.select do |dupe_table, dupe_pairs|
+              dupe_table != table_name && assoc_pairs.length > 0 && assoc_pairs.length == dupe_pairs.length &&
+              dupe_pairs.all? { |pair_name, _v3| assoc_pairs.keys.include?(pair_name) }
+            end
+            seed_rows << "  if ActiveRecord::Migration.table_exists?('#{table_name}')\n"
+            unless dupes.empty?
+              seed_rows << "    # Duplicate data found in: #{dupes.keys.join(', ')}\n"
+              dupes.keys.each { |k| dupe_list << "#{table_name} | #{k}" }
+            end
+            seed_rows << "    puts 'Airtable associations for #{table_name.camelize.singularize}'\n"
+            assoc_pairs.each do |_k2, pair_values|
+              seed_rows << "#{table_name.singularize.camelize}.create(#{pair_values})\n"
+            end
+            seed_rows << "  end\n"
+            airtable_assocs_done[table_name] = assoc_pairs
           end
-          seed_rows << "  if ActiveRecord::Migration.table_exists?('#{table_name}')\n"
-          seed_rows << "    # Duplicate data found in: #{dupes.keys.join(', ')}\n" unless dupes.empty?
-          seed_rows << "    puts 'Seeding Airtable associations for #{table_name.camelize.singularize}'\n"
-          assoc_pairs.each do |_k2, pair_values|
-            seed_rows << "#{table_name.singularize.camelize}.create(#{pair_values})\n"
+
+          if dupe_list.present?
+            puts "\nAssociative tables with duplicate data:"
+            dupe_list.each { |entry| puts "  #{entry}" }
+            puts '(You can safely remove one of the two tables in each of the pairs listed above.)'
           end
-          seed_rows << "  end\n"
-          airtable_assocs_done[table_name] = assoc_pairs
         end
         seeds_file.write(seed_rows) unless seed_rows.blank?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.246
+  version: 1.0.247
 platform: ruby
 authors:
 - Lorin Thwaits