brick 1.0.157 → 1.0.160

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 995a300b0971af02a39ed75857ce349c99720068555cbb1d6311a75d9a13f2b8
-  data.tar.gz: e9153dac19552fc8dd581774f89b9ed682ac040b5a4dc0d47f4b28fe079ca36d
+  metadata.gz: 735ad34b99ba52ae2575c786fdee6c359c5c53e6d2edf53b19bbb5d1f02869ec
+  data.tar.gz: c603e9adebe13192e4be8724b51d563a6b39f89b15c61fab253debb9fc959a66
 SHA512:
-  metadata.gz: 4c0c8553d5ef266aa6e947d6f0dd9ee4ae23d64118cd3c69565345747be0afa4de63be999976bd8e4fed55ebec2f3551aa87a4f4b84dee0a3dced188d23260f6
-  data.tar.gz: a7e0dbdd27c5d0905d7acf0a7a3f6fb5e254556ef65a0633a3021c395664c65f152afd3cecc53992c0f5da0095a1246b10d14898c34d82c60fc1cec298e62a68
+  metadata.gz: 14b5a64e366d218ac78bb3ec26370cddcdb506ee292974321a76331a40d272a33ce49b9cb4911314a7e33835bf44255dda73c04449062e159b499e2e0d88c61f
+  data.tar.gz: cfa821c073296681b4b49e0d58538e076ac50ae1ea65b2df6ea8af1c92477842ee737c3d5950d803ce45f52daf48fca065f28bf6cc6a5e6518c408a64305ada6

data/lib/brick/compatibility.rb

@@ -97,11 +97,13 @@ if Object.const_defined?('ActionPack') && !ActionPack.respond_to?(:version)
     end
   end
 end
-require 'action_view' # Needed for Rails <= 4.0
-if Object.const_defined?('ActionView') && !ActionView.respond_to?(:version)
-  module ActionView
-    def self.version
-      ActionPack.version
+if Bundler.locked_gems&.dependencies.key?('action_view')
+  require 'action_view' # Needed for Rails <= 4.0
+  if Object.const_defined?('ActionView') && !ActionView.respond_to?(:version)
+    module ActionView
+      def self.version
+        ActionPack.version
+      end
     end
   end
 end

data/lib/brick/extensions.rb

@@ -30,14 +30,14 @@
 
 # Drag something like HierModel#name onto the rows and have it automatically add five columns -- where type=zone / where type = section / etc
 
-# Support for Postgres / MySQL enums (add enum to model, use model enums to make a drop-down in the UI)
-
-# Currently quadrupling up routes
-
 # Modal pop-up things for editing large text / date ranges / hierarchies of data
 
 # For recognised self-references, have the show page display all related objects up to the parent (or the start of a circular reference)
 
+# When creating or updating an object through an auto-generated controller, it always goes to an auto-generated view template even if the user has supplied their own index.html.erb (or similar) view template
+
+# Upon creation of a new object, when going to the index page, highlight this new object and scroll it into view (likely to the very bottom of everything, although might be sorted differently)
+
 # ==========================================================
 # Dynamically create model or controller classes when needed
 # ==========================================================
@@ -89,6 +89,13 @@ module ActiveRecord
       def brick_foreign_type(assoc)
         reflect_on_association(assoc).foreign_type || "#{assoc}_type"
       end
+
+      def _brick_all_fields
+        rtans = if respond_to?(:rich_text_association_names)
+                  rich_text_association_names&.map { |rtan| rtan.to_s.start_with?('rich_text_') ? rtan[10..-1] : rtan }
+                end
+        columns_hash.keys.map(&:to_sym) + (rtans || [])
+      end
     end
 
     def self._brick_primary_key(relation = nil)
@@ -357,7 +364,7 @@ module ActiveRecord
               # Support nested attributes which use the friendly_id gem
               assoc.klass._brick_nested_friendly_id if Object.const_defined?('FriendlyId') &&
                                                        assoc.klass.instance_variable_get(:@friendly_id_config)
-              new_attrib_text = assoc.klass._brick_find_permits(assoc, (new_permits = assoc.klass.columns_hash.keys.map(&:to_sym)), done_permits)
+              new_attrib_text = assoc.klass._brick_find_permits(assoc, (new_permits = assoc.klass._brick_all_fields), done_permits)
               new_permits << :_destroy
               current_permits << { "#{assoc.name}_attributes".to_sym => new_permits }
               s << "#{assoc.name}_attributes: #{new_attrib_text}"
@@ -2152,13 +2159,7 @@ class Object
           code << "  end\n"
           self.define_method :new do
             _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
-            if (new_obj = model.new).respond_to?(:serializable_hash)
-              # Convert any Filename objects with nil into an empty string so that #encode can be called on them
-              new_obj.serializable_hash.each do |k, v|
-                new_obj.send("#{k}=", ActiveStorage::Filename.new('')) if v.is_a?(ActiveStorage::Filename) && !v.instance_variable_get(:@filename)
-              end if Object.const_defined?('ActiveStorage')
-            end
-            new_obj.attribute_names.each do |a|
+            new_params = model.attribute_names.each_with_object({}) do |a, s|
               if (val = params["__#{a}"])
                 # val = case new_obj.class.column_for_attribute(a).type
                 #       when :datetime, :date, :time, :timestamp
@@ -2166,9 +2167,15 @@ class Object
                 #       else
                 #         val
                 #       end
-                new_obj.send("#{a}=", val)
+                s[a] = val
               end
             end
+            if (new_obj = model.new(new_params)).respond_to?(:serializable_hash)
+              # Convert any Filename objects with nil into an empty string so that #encode can be called on them
+              new_obj.serializable_hash.each do |k, v|
+                new_obj.send("#{k}=", ActiveStorage::Filename.new('')) if v.is_a?(ActiveStorage::Filename) && !v.instance_variable_get(:@filename)
+              end if Object.const_defined?('ActiveStorage')
+            end
             instance_variable_set("@#{singular_table_name}".to_sym, new_obj)
             add_csp_hash
           end
@@ -2192,7 +2199,8 @@ class Object
               render json: { result: ::Brick.unexclude_column(table_name, col) }
             else
               @_lookup_context.instance_variable_set("@#{singular_table_name}".to_sym,
-                                                     model.send(:create, send(params_name_sym)))
+                                                     (created_obj = model.send(:create, send(params_name_sym))))
+              # %%% Surface any errors to the user in a flash message
               @_lookup_context.instance_variable_set(:@_brick_model, model)
               index
               render :index
@@ -2310,7 +2318,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits_txt = model._brick_find_permits(model, permits = model.columns_hash.keys.map(&:to_sym))
+            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields)
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
             code << "  end\n"

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

@@ -713,12 +713,9 @@ window.addEventListener(\"popstate\", linkSchemas);
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :has_many
-                                            source.inverse_of&.name # For HM -> HM style HMT
-                                          else # belongs_to or has_one
-                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
-                                          end
-                                 # If there is no inverse available for the source belongs_to association, make one based on the class name
+                                 # Should handle standard HMT, which is HM -> BT, as well as HM -> HM style HMT
+                                 tbl_nm = hm_assoc.source_reflection&.inverse_of&.name
+                                 # If there is no inverse available for the source belongs_to association, infer one based on the class name
                                  unless tbl_nm
                                    tbl_nm = associative.class_name.underscore
                                    tbl_nm.slice!(0) if tbl_nm[0] == '/'
@@ -1670,79 +1667,9 @@ end
      end
 %>
   <br><br>
-<%= form_for(obj.becomes(#{model_name}), options) do |f| %>
-  <table class=\"shadow\">
-  <% has_fields = false
-     # If it's a new record, set any default polymorphic types
-     bts.each do |_k, v|
-       if v[2]
-         @#{obj_name}.send(\"#\{model.brick_foreign_type(v.first)}=\", v[1].first&.first&.name)
-       end
-     end if @#{obj_name}.new_record?
-     @#{obj_name}.attributes.each do |k, val|
-       next if !(col = #{model_name}.columns_hash[k]) ||
-               (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
-               ::Brick.config.metadata_columns.include?(k) %>
-    <tr>
-    <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
-<%    has_fields = true
-      if (bt = bts[k])
-        # Add a final member in this array with descriptive options to be used in <select> drop-downs
-        bt_name = bt[1].map { |x| x.first.name }.join('/')
-        # %%% Only do this if the user has permissions to edit this bt field
-        if bt[2] # Polymorphic?
-          poly_class_name = orig_poly_name = @#{obj_name}.send(model.brick_foreign_type(bt.first))
-          bt_pair = nil
-          loop do
-            bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
-            # Accommodate any valid STI by going up the chain of inheritance
-            break unless bt_pair.nil? && poly_class_name = ::Brick.existing_stis[poly_class_name]
-          end
-          puts \"*** Might be missing an STI class called #\{orig_poly_name\} whose base class should have this:
-***   has_many :#{table_name}, as: :#\{bt.first\}
-*** Can probably auto-configure everything using these lines in an initialiser:
-***   Brick.sti_namespace_prefixes = { '::#\{orig_poly_name\}' => 'SomeParentModel' }
-***   Brick.polymorphics = { '#{table_name}.#\{bt.first\}' => ['SomeParentModel'] }\" if bt_pair.nil?
-          # descrips = @_brick_bt_descrip[bt.first][bt_class]
-          poly_id = @#{obj_name}.send(\"#\{bt.first\}_id\")
-          # bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
-        end
-        bt_pair ||= bt[1].first # If there's no polymorphism (or polymorphism status is unknown), just get the first one
-        bt_class = bt_pair&.first
-        if bt.length < 4
-          bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
-          # %%% Accommodate composite keys for obj.pk at the end here
-          collection, descrip_cols = bt_class&.order(Arel.sql(\"#\{bt_class.table_name}.#\{obj_pk = bt_class.primary_key}\"))&.brick_list
-          collection&.brick_(:each) do |obj|
-            option_detail << [
-              obj.brick_descrip(
-                descrip_cols&.first&.map { |col| obj.send(col.last) },
-                obj_pk
-              ), obj.send(obj_pk)
-            ]
-          end
-        end %>
-        BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
-    <% else %>
-      <%= #{model_name}.human_attribute_name(k, { default: k }) %>
-    <% end %>
-    </th>
-    <td>
-      <%= f.brick_field(k, html_options = {}, val, col, bt, bt_class, bt_name, bt_pair) %>
-    </td>
-    </tr>
-  <% end
-  if has_fields %>
-    <tr><td colspan=\"2\"><%= f.submit({ class: 'update' }) %></td></tr>
-  <% else %>
-    <tr><td colspan=\"2\">(No displayable fields)</td></tr>
-  <% end %>
-  </table>#{
-  "<%= begin
-         ::Brick::Rails.display_binary(obj&.blob&.download, 500_000)&.html_safe
-       rescue
-       end %>" if model_name == 'ActiveStorage::Attachment'}
-<%  end %>
+
+<%= # Write out the mega-form
+    brick_form_for(obj, options, #{model_name}, bts, #{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/frameworks/rails/form_builder.rb

@@ -20,7 +20,14 @@ module Brick::Rails::FormBuilder
 
       html_options[:prompt] = "Select #{bt_name}"
       out << self.select(method.to_sym, bt[3], { value: val || '^^^brick_NULL^^^' }, html_options)
-      bt_link = if (bt_obj = bt_class&.find_by(bt_pair[1] => val))
+      bt_obj = nil
+      begin
+        bt_obj = bt_class&.find_by(bt_pair[1] => val)
+      rescue ActiveRecord::SubclassNotFound => e
+        # %%% Would be cool to indicate to the user that a subclass is missing.
+        # Its name starts at:  e.message.index('failed to locate the subclass: ') + 31
+      end
+      bt_link = if bt_obj
                   bt_path = template.send(
                               "#{bt_class.base_class._brick_index(:singular)}_path".to_sym,
                               bt_obj.send(bt_class.primary_key.to_sym)
@@ -60,9 +67,14 @@ module Brick::Rails::FormBuilder
       when :boolean
         out << self.check_box(method.to_sym)
       when :integer, :decimal, :float
-        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' })
+        if model.respond_to?(:attribute_types) && (enum_type = model.attribute_types[method]).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)
+        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' })
+        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] })
@@ -100,7 +112,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.to_sym, { class: 'jsonpicker', value: val_str&.gsub('`', '^^br_btick__')&.tr('\"', '`')&.html_safe }))
         out << "<div id=\"_br_json_#{self.field_id(method)}\"></div>"
       else
         is_revert = false

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

@@ -157,7 +157,7 @@ module Brick::Rails::FormTags
                 out << link_to(ho_txt, send("#{hm_klass.base_class._brick_index(:singular)}_path".to_sym, ho_id))
               end
             elsif obj.respond_to?(ct_col = hms_col[1].to_sym) && (ct = obj.send(ct_col)&.to_i)&.positive?
-              predicates = hms_col[2].each_with_object({}) { |v, s| s[v.first] = v.last.is_a?(String) ? v.last : obj.send(v.last) }
+              predicates = hms_col[2].each_with_object({}) { |v, s| s["__#{v.first}"] = v.last.is_a?(String) ? v.last : obj.send(v.last) }
               predicates.each { |k, v| predicates[k] = klass.name if v == '[sti_type]' }
               out << "#{link_to("#{ct || 'View'} #{hms_col.first}",
                                 send("#{hm_klass._brick_index}_path".to_sym, predicates))}\n"
@@ -203,6 +203,100 @@ module Brick::Rails::FormTags
     out.html_safe
   end # brick_grid
 
+  # Our mega show/new/update form
+  def brick_form_for(obj, options = {}, model = obj.class, bts = {}, pk = (obj.class.primary_key || []))
+    pk = [pk] unless pk.is_a?(Array)
+    pk.map!(&:to_s)
+    form_for(obj.becomes(model), options) do |f|
+      out = +'<table class="shadow">'
+      has_fields = false
+      # If it's a new record, set any default polymorphic types
+      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?
+      rtans = model.rich_text_association_names if model.respond_to?(:rich_text_association_names)
+      (model.column_names + (rtans || [])).each do |k|
+        next if (pk.include?(k) && !bts.key?(k)) ||
+                ::Brick.config.metadata_columns.include?(k)
+
+        col = model.columns_hash[k]
+        if !col && rtans&.include?(k)
+          k = k[10..-1] if k.start_with?('rich_text_')
+          col = (rt_col ||= ActiveRecord::ConnectionAdapters::Column.new(
+                              '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: 'varchar', type: :text)
+                            )
+                )
+        end
+        val = obj.attributes[k]
+        out << "
+    <tr>
+    <th class=\"show-field\"#{" title=\"#{col&.comment}\"".html_safe if col&.respond_to?(:comment) && !col&.comment.blank?}>"
+        has_fields = true
+        if (bt = bts[k])
+          # Add a final member in this array with descriptive options to be used in <select> drop-downs
+          bt_name = bt[1].map { |x| x.first.name }.join('/')
+          # %%% Only do this if the user has permissions to edit this bt field
+          if bt[2] # Polymorphic?
+            poly_class_name = orig_poly_name = obj.send(model.brick_foreign_type(bt.first))
+            bt_pair = nil
+            loop do
+              bt_pair = bt[1].find { |pair| pair.first.name == poly_class_name }
+              # Accommodate any valid STI by going up the chain of inheritance
+              break unless bt_pair.nil? && poly_class_name = ::Brick.existing_stis[poly_class_name]
+            end
+            puts "*** Might be missing an STI class called #{orig_poly_name} whose base class should have this:
+***   has_many :#{table_name}, as: :#{bt.first}
+*** Can probably auto-configure everything using these lines in an initialiser:
+***   Brick.sti_namespace_prefixes = { '::#{orig_poly_name}' => 'SomeParentModel' }
+***   Brick.polymorphics = { '#{table_name}.#{bt.first}' => ['SomeParentModel'] }" if bt_pair.nil?
+            # descrips = @_brick_bt_descrip[bt.first][bt_class]
+            poly_id = obj.send("#{bt.first}_id")
+            # bt_class.order(obj_pk = bt_class.primary_key).each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
+          end
+          bt_pair ||= bt[1].first # If there's no polymorphism (or polymorphism status is unknown), just get the first one
+          bt_class = bt_pair&.first
+          if bt.length < 4
+            bt << (option_detail = [["(No #{bt_name} chosen)", '^^^brick_NULL^^^']])
+            # %%% Accommodate composite keys for obj.pk at the end here
+            collection, descrip_cols = bt_class&.order(Arel.sql("#{bt_class.table_name}.#{obj_pk = bt_class.primary_key}"))&.brick_list
+            collection&.brick_(:each) do |obj|
+              option_detail << [
+                obj.brick_descrip(
+                  descrip_cols&.first&.map { |col2| obj.send(col2.last) },
+                  obj_pk
+                ), obj.send(obj_pk)
+              ]
+            end
+          end
+          out << "BT #{bt_class&.bt_link(bt.first) || orig_poly_name}"
+        else
+          out << model.human_attribute_name(k, { default: k })
+        end
+        out << "
+    </th>
+    <td>
+      #{f.brick_field(k, html_options = {}, val, col, bt, bt_class, bt_name, bt_pair)}
+    </td>
+  </tr>"
+      end
+      if has_fields
+        out << "<tr><td colspan=\"2\">#{f.submit({ class: 'update' })}</td></tr>"
+      else
+        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
+        rescue
+        end
+      end
+      out.html_safe
+    end
+  end # brick_form_for
+
   def link_to_brick(*args, **kwargs)
     return unless ::Brick.config.mode == :on
 

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -221,8 +221,8 @@ module Brick
               hm_models = ActiveRecord::Base.descendants.select do |m|
                 m.reflect_on_all_associations.any? { |assoc| !assoc.belongs_to? && assoc.options[:as]&.to_sym == a.name }
               end
-              # No need to include subclassed models if their parent is already in the list
-              hm_models.reject! { |m| hm_models.any? { |parent| parent != m && m < parent } }
+              # No need to include models with no table, or subclassed models if their parent is already in the list
+              hm_models.reject! { |m| !m.table_exists? || hm_models.any? { |parent| parent != m && m < parent } }
               if hm_models.empty?
                 puts "Missing any real indication as to which models \"has_many\" this polymorphic BT in model #{a.active_record.name}:"
                 puts "  belongs_to :#{a.name}, polymorphic: true"
@@ -1112,20 +1112,22 @@ require 'active_record/relation'
 require 'active_record/relation/query_methods' if ActiveRecord.version < ::Gem::Version.new('5')
 require 'rails/railtie' if ActiveRecord.version < ::Gem::Version.new('4.2')
 
-# Rake tasks
-class Railtie < ::Rails::Railtie
-  Dir.glob("#{File.expand_path(__dir__)}/brick/tasks/**/*.rake").each { |task| load task }
-end
+if Object.const_defined?('Rails')
+  # Rake tasks
+  class Railtie < ::Rails::Railtie
+    Dir.glob("#{File.expand_path(__dir__)}/brick/tasks/**/*.rake").each { |task| load task }
+  end
 
-# Rails < 4.2 does not have env
-module ::Rails
-  unless respond_to?(:env)
-    def self.env
-      @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")
-    end
+  # Rails < 4.2 does not have env
+  module ::Rails
+    unless respond_to?(:env)
+      def self.env
+        @_env ||= ActiveSupport::StringInquirer.new(ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")
+      end
 
-    def self.env=(environment)
-      @_env = ActiveSupport::StringInquirer.new(environment)
+      def self.env=(environment)
+        @_env = ActiveSupport::StringInquirer.new(environment)
+      end
     end
   end
 end

data/lib/generators/brick/install_generator.rb

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

data/lib/generators/brick/migration_builder.rb

@@ -0,0 +1,343 @@
+module Brick
+  module MigrationBuilder
+    include FancyGets
+
+    # Many SQL types are the same as their migration data type name:
+    #   text, integer, bigint, date, boolean, decimal, float
+    # These however are not:
+    SQL_TYPES = { 'character varying' => 'string',
+                  'character' => 'string', # %%% Need to put in "limit: 1"
+                  'xml' => 'text',
+                  'bytea' => 'binary',
+                  'timestamp without time zone' => 'timestamp',
+                  'timestamp with time zone' => 'timestamp',
+                  'time without time zone' => 'time',
+                  'time with time zone' => 'time',
+                  'double precision' => 'float',
+                  'smallint' => 'integer', # %%% Need to put in "limit: 2"
+                  'ARRAY' => 'string', # Note that we'll also add ", array: true"
+                  # Oracle data types
+                  'VARCHAR2' => 'string',
+                  'CHAR' => 'string',
+                  ['NUMBER', 22] => 'integer',
+                  /^INTERVAL / => 'string', # Time interval stuff like INTERVAL YEAR(2) TO MONTH, INTERVAL '999' DAY(3), etc
+                  'XMLTYPE' => 'xml',
+                  'RAW' => 'binary',
+                  'SDO_GEOMETRY' => 'geometry',
+                  # MSSQL data types
+                  'int' => 'integer',
+                  'nvarchar' => 'string',
+                  'nchar' => 'string',
+                  'datetime2' => 'timestamp',
+                  'bit' => 'boolean',
+                  'varbinary' => 'binary',
+                  # Sqlite data types
+                  'TEXT' => 'text',
+                  '' => 'string',
+                  'INTEGER' => 'integer',
+                  'REAL' => 'float',
+                  'BLOB' => 'binary',
+                  'TIMESTAMP' => 'timestamp',
+                  'DATETIME' => 'timestamp'
+                }
+    # (Still need to find what "inet" and "json" data types map to.)
+
+    class << self
+      def check_folder(is_insert_versions = true, is_delete_versions = false)
+        versions_to_delete_or_append = nil
+        if Dir.exist?(mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{::Rails.root}/db/migrate")
+          if Dir["#{mig_path}/**/*.rb"].present?
+            puts "WARNING: migrations folder #{mig_path} appears to already have ruby files present."
+            mig_path2 = "#{::Rails.root}/tmp/brick_migrations"
+            is_insert_versions = false unless mig_path == mig_path2
+            if Dir.exist?(mig_path2)
+              if Dir["#{mig_path2}/**/*.rb"].present?
+                puts "As well, temporary folder #{mig_path2} also has ruby files present."
+                puts "Choose a destination -- all existing .rb files will be removed:"
+                mig_path2 = gets_list(list: ['Cancel operation!', "Append migration files into #{mig_path} anyway", mig_path, mig_path2])
+                return if mig_path2.start_with?('Cancel')
+
+                existing_mig_files = Dir["#{mig_path2}/**/*.rb"]
+                if (is_insert_versions = mig_path == mig_path2)
+                  versions_to_delete_or_append = existing_mig_files.map { |ver| ver.split('/').last.split('_').first }
+                end
+                if mig_path2.start_with?('Append migration files into ')
+                  mig_path2 = mig_path
+                else
+                  is_delete_versions = true
+                  existing_mig_files.each { |rb| File.delete(rb) }
+                end
+              else
+                puts "Using temporary folder #{mig_path2} for created migration files.\n\n"
+              end
+            else
+              puts "Creating the temporary folder #{mig_path2} for created migration files.\n\n"
+              Dir.mkdir(mig_path2)
+            end
+            mig_path = mig_path2
+          else
+            puts "Using standard migration folder #{mig_path} for created migration files.\n\n"
+          end
+        else
+          puts "Creating standard ActiveRecord migration folder #{mig_path} to hold new migration files.\n\n"
+          Dir.mkdir(mig_path)
+        end
+        [mig_path, is_insert_versions, is_delete_versions]
+      end
+
+      def generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions, relations = ::Brick.relations)
+        is_sqlite = ActiveRecord::Base.connection.adapter_name == 'SQLite'
+        key_type = ((is_sqlite || ActiveRecord.version < ::Gem::Version.new('5.1')) ? 'integer' : 'bigint')
+        is_4x_rails = ActiveRecord.version < ::Gem::Version.new('5.0')
+        ar_version = "[#{ActiveRecord.version.segments[0..1].join('.')}]" unless is_4x_rails
+
+        schemas = chosen.each_with_object({}) do |v, s|
+          if (v_parts = v.split('.')).length > 1
+            s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
+          end
+        end
+        # Start the timestamps back the same number of minutes from now as expected number of migrations to create
+        current_mig_time = Time.now - (schemas.length + chosen.length).minutes
+        done = []
+        fks = {}
+        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.
+        versions_to_create = [] # Resulting versions to be used when updating the schema_migrations table
+        ar_base = Object.const_defined?(:ApplicationRecord) ? ApplicationRecord : Class.new(ActiveRecord::Base)
+        # 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
+        # no more migrations can be created.  (At that point hopefully all tables are accounted for.)
+        while (fringe = chosen.reject do |tbl|
+                          snag_fks = []
+                          snags = relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
+                            v[:is_bt] && !v[:polymorphic] &&
+                            tbl != v[:inverse_table] && # Ignore self-referencing associations (stuff like "parent_id")
+                            !done.include?(v[:inverse_table]) &&
+                            ::Brick.config.ignore_migration_fks.exclude?(snag_fk = "#{tbl}.#{v[:fk]}") &&
+                            snag_fks << snag_fk
+                          end
+                          if snags&.present?
+                            # puts snag_fks.inspect
+                            stuck[tbl] = snags
+                          end
+                        end).present?
+          fringe.each do |tbl|
+            next unless (relation = relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
+
+            pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ar_base.primary_key].flatten.sort)
+            # In case things aren't as standard
+            if pkey_cols.empty?
+              pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type
+                            arpk
+                          elsif rpk.first
+                            rpk
+                          end
+            end
+            schema = if (tbl_parts = tbl.split('.')).length > 1
+                      if tbl_parts.first == (::Brick.default_schema || 'public')
+                        tbl_parts.shift
+                        nil
+                      else
+                        tbl_parts.first
+                      end
+                    end
+            unless schema.blank? || built_schemas.key?(schema)
+              mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
+              migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time += 1.minute, ar_version, mig)
+              built_schemas[schema] = nil
+            end
+
+            # %%% For the moment we're skipping polymorphics
+            fkey_cols = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
+            # If the primary key is also used as a foreign key, will need to do  id: false  and then build out
+            # a column definition which includes :primary_key -- %%% also using a data type of bigserial or serial
+            # if this one has come in as bigint or integer.
+            pk_is_also_fk = fkey_cols.any? { |assoc| pkey_cols&.first == assoc[:fk] } ? pkey_cols&.first : nil
+            # Support missing primary key (by adding:  , id: false)
+            id_option = if pk_is_also_fk || !pkey_cols&.present?
+                          needs_serial_col = true
+                          +', id: false'
+                        elsif ((pkey_col_first = (col_def = relation[:cols][pkey_cols&.first])&.first) &&
+                              (pkey_col_first = SQL_TYPES[pkey_col_first] || SQL_TYPES[col_def&.[](0..1)] ||
+                                                SQL_TYPES.find { |r| r.first.is_a?(Regexp) && pkey_col_first =~ r.first }&.last ||
+                                                pkey_col_first
+                              ) != key_type
+                              )
+                          case pkey_col_first
+                          when 'integer'
+                            +', id: :serial'
+                          when 'bigint'
+                            +', id: :bigserial'
+                          else
+                            +", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
+                          end +
+                            (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
+                        end
+            if !id_option && pkey_cols.sort != arpk
+              id_option = +", primary_key: :#{pkey_cols.first}"
+            end
+            if !is_4x_rails && (comment = relation&.fetch(:description, nil))&.present?
+              (id_option ||= +'') << ", comment: #{comment.inspect}"
+            end
+            # Find the ActiveRecord class in order to see if the columns have comments
+            unless is_4x_rails
+              klass = begin
+                        tbl.tr('.', '/').singularize.camelize.constantize
+                      rescue StandardError
+                      end
+              if klass
+                unless ActiveRecord::Migration.table_exists?(klass.table_name)
+                  puts "WARNING: Unable to locate table #{klass.table_name} (for #{klass.name})."
+                  klass = nil
+                end
+              end
+            end
+            # Refer to this table name as a symbol or dotted string as appropriate
+            tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
+            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
+            add_fks = [] # Track foreign keys to add after table creation
+            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
+              suffix = col_type[3] || pkey_cols&.include?(col) ? +', null: false' : +''
+              suffix << ', array: true' if (col_type.first == 'ARRAY')
+              if !is_4x_rails && klass && (comment = klass.columns_hash.fetch(col, nil)&.comment)&.present?
+                suffix << ", comment: #{comment.inspect}"
+              end
+              # Determine if this column is used as part of a foreign key
+              if (fk = fkey_cols.find { |assoc| col == assoc[:fk] })
+                to_table = fk[:inverse_table].split('.')
+                to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
+                if needs_serial_col && pkey_cols&.include?(col) && (new_serial_type = {'integer' => 'serial', 'bigint' => 'bigserial'}[sql_type])
+                  sql_type = new_serial_type
+                  needs_serial_col = false
+                end
+                if fk[:fk] != "#{fk[:assoc_name].singularize}_id" # Need to do our own foreign_key tricks, not use references?
+                  column = fk[:fk]
+                  mig << emit_column(sql_type, column, suffix)
+                  add_fks << [to_table, column, relations[fk[:inverse_table]]]
+                else
+                  suffix << ", type: :#{sql_type}" unless sql_type == key_type
+                  # Will the resulting default index name be longer than what Postgres allows?  (63 characters)
+                  if (idx_name = ActiveRecord::Base.connection.index_name(tbl, {column: col})).length > 63
+                    # Try to find a shorter name that hasn't been used yet
+                    unless indexes.key?(shorter = idx_name[0..62]) ||
+                          indexes.key?(shorter = idx_name.tr('_', '')[0..62]) ||
+                          indexes.key?(shorter = idx_name.tr('aeio', '')[0..62])
+                      puts "Unable to easily find unique name for index #{idx_name} that is shorter than 64 characters,"
+                      puts "so have resorted to this GUID-based identifier: #{shorter = "#{tbl[0..25]}_#{::SecureRandom.uuid}"}."
+                    end
+                    suffix << ", index: { name: '#{shorter || idx_name}' }"
+                    indexes[shorter || idx_name] = nil
+                  end
+                  primary_key = nil
+                  begin
+                    primary_key = relations[fk[:inverse_table]][:class_name]&.constantize&.primary_key
+                  rescue NameError => e
+                    primary_key = ar_base.primary_key
+                  end
+                  mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table}#{", primary_key: :#{primary_key}" if primary_key != ar_base.primary_key} }\n"
+                end
+              else
+                next if !id_option&.end_with?('id: false') && pkey_cols&.include?(col)
+
+                # See if there are generic timestamps
+                if sql_type == 'timestamp' && ['created_at','updated_at'].include?(col)
+                  possible_ts << [col, !col_type[3]]
+                else
+                  mig << emit_column(sql_type, col, suffix)
+                end
+              end
+            end
+            if possible_ts.length == 2 && # Both created_at and updated_at
+              # Rails 5 and later timestamps default to NOT NULL
+              (possible_ts.first.last == is_4x_rails && possible_ts.last.last == is_4x_rails)
+              mig << "\n      t.timestamps\n"
+            else # Just one or the other, or a nullability mismatch
+              possible_ts.each { |ts| emit_column('timestamp', ts.first, nil) }
+            end
+            mig << "    end\n"
+            if pk_is_also_fk
+              mig << "    reversible do |dir|\n"
+              mig << "      dir.up { execute('ALTER TABLE #{tbl} ADD PRIMARY KEY (#{pk_is_also_fk})') }\n"
+              mig << "    end\n"
+            end
+            add_fks.each do |add_fk|
+              is_commented = false
+              # add_fk[2] holds the inverse relation
+              unless (pk = add_fk[2][:pkey].values.flatten&.first)
+                is_commented = true
+                mig << "    # (Unable to create relationship because primary key is missing on table #{add_fk[0]})\n"
+                # No official PK, but if coincidentally there's a column of the same name, take a chance on it
+                pk = (add_fk[2][:cols].key?(add_fk[1]) && add_fk[1]) || '???'
+              end
+              #                                                                 to_table               column
+              mig << "    #{'# ' if is_commented}add_foreign_key #{tbl_code}, #{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
+            end
+            mig << "  end\n"
+            versions_to_create << migration_file_write(mig_path, "create_#{tbl_parts.map(&:underscore).join('_')}", current_mig_time += 1.minute, ar_version, mig)
+          end
+          done.concat(fringe)
+          chosen -= done
+        end
+
+        stuck_counts = Hash.new { |h, k| h[k] = 0 }
+        chosen.each do |leftover|
+          puts "Can't do #{leftover} because:\n  #{stuck[leftover].map do |snag|
+            stuck_counts[snag.last[:inverse_table]] += 1
+            snag.last[:assoc_name]
+          end.join(', ')}"
+        end
+        if mig_path.start_with?(cur_path = ::Rails.root.to_s)
+          pretty_mig_path = mig_path[cur_path.length..-1]
+        end
+        puts "\n*** Created #{done.length} migration files under #{pretty_mig_path || mig_path} ***"
+        if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
+          puts "-----------------------------------------"
+          puts "Unable to create migrations for #{stuck_sorted.length} tables#{
+            ".  Here's the top 5 blockers" if stuck_sorted.length > 5
+          }:"
+          pp stuck_sorted[0..4]
+        else # Successful, and now we can update the schema_migrations table accordingly
+          unless ActiveRecord::Migration.table_exists?(ActiveRecord::Base.schema_migrations_table_name)
+            ActiveRecord::SchemaMigration.create_table
+          end
+          # Remove to_delete - to_create
+          if ((versions_to_delete_or_append ||= []) - versions_to_create).present? && is_delete_versions
+            ActiveRecord::Base.execute_sql("DELETE FROM #{
+              ActiveRecord::Base.schema_migrations_table_name} WHERE version IN (#{
+              (versions_to_delete_or_append - versions_to_create).map { |vtd| "'#{vtd}'" }.join(', ')}
+            )")
+          end
+          # Add to_create - to_delete
+          if is_insert_versions && ((versions_to_create ||= []) - versions_to_delete_or_append).present?
+            ActiveRecord::Base.execute_sql("INSERT INTO #{
+              ActiveRecord::Base.schema_migrations_table_name} (version) VALUES #{
+              (versions_to_create - versions_to_delete_or_append).map { |vtc| "('#{vtc}')" }.join(', ')
+            }")
+          end
+        end
+      end
+
+    private
+
+      def emit_column(type, name, suffix)
+        "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
+      end
+
+      def migration_file_write(mig_path, name, current_mig_time, ar_version, mig)
+        File.open("#{mig_path}/#{version = current_mig_time.strftime('%Y%m%d%H%M00')}_#{name}.rb", "w") do |f|
+          f.write "class #{name.camelize} < ActiveRecord::Migration#{ar_version}\n"
+          f.write mig
+          f.write "end\n"
+        end
+        version
+      end
+    end
+  end
+end

data/lib/generators/brick/migrations_generator.rb

@@ -3,52 +3,12 @@
 require 'rails/generators'
 require 'rails/generators/active_record'
 require 'fancy_gets'
+require 'generators/brick/migration_builder'
 
 module Brick
   # Auto-generates migration files
   class MigrationsGenerator < ::Rails::Generators::Base
-    include FancyGets
-    # include ::Rails::Generators::Migration
-
-    # Many SQL types are the same as their migration data type name:
-    #   text, integer, bigint, date, boolean, decimal, float
-    # These however are not:
-    SQL_TYPES = { 'character varying' => 'string',
-                  'character' => 'string', # %%% Need to put in "limit: 1"
-                  'xml' => 'text',
-                  'bytea' => 'binary',
-                  'timestamp without time zone' => 'timestamp',
-                  'timestamp with time zone' => 'timestamp',
-                  'time without time zone' => 'time',
-                  'time with time zone' => 'time',
-                  'double precision' => 'float',
-                  'smallint' => 'integer', # %%% Need to put in "limit: 2"
-                  'ARRAY' => 'string', # Note that we'll also add ", array: true"
-                  # Oracle data types
-                  'VARCHAR2' => 'string',
-                  'CHAR' => 'string',
-                  ['NUMBER', 22] => 'integer',
-                  /^INTERVAL / => 'string', # Time interval stuff like INTERVAL YEAR(2) TO MONTH, INTERVAL '999' DAY(3), etc
-                  'XMLTYPE' => 'xml',
-                  'RAW' => 'binary',
-                  'SDO_GEOMETRY' => 'geometry',
-                  # MSSQL data types
-                  'int' => 'integer',
-                  'nvarchar' => 'string',
-                  'nchar' => 'string',
-                  'datetime2' => 'timestamp',
-                  'bit' => 'boolean',
-                  'varbinary' => 'binary',
-                  # Sqlite data types
-                  'TEXT' => 'text',
-                  '' => 'string',
-                  'INTEGER' => 'integer',
-                  'REAL' => 'float',
-                  'BLOB' => 'binary',
-                  'TIMESTAMP' => 'timestamp',
-                  'DATETIME' => 'timestamp'
-                }
-    # (Still need to find what "inet" and "json" data types map to.)
+    include ::Brick::MigrationBuilder
 
     desc 'Auto-generates migration files for an existing database.'
 
@@ -63,294 +23,12 @@ module Brick
         return
       end
 
-      is_sqlite = ActiveRecord::Base.connection.adapter_name == 'SQLite'
-      key_type = ((is_sqlite || ActiveRecord.version < ::Gem::Version.new('5.1')) ? 'integer' : 'bigint')
-      is_4x_rails = ActiveRecord.version < ::Gem::Version.new('5.0')
-      ar_version = "[#{ActiveRecord.version.segments[0..1].join('.')}]" unless is_4x_rails
-      is_insert_versions = true
-      is_delete_versions = false
-      versions_to_delete_or_append = nil
-      if Dir.exist?(mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{::Rails.root}/db/migrate")
-        if Dir["#{mig_path}/**/*.rb"].present?
-          puts "WARNING: migrations folder #{mig_path} appears to already have ruby files present."
-          mig_path2 = "#{::Rails.root}/tmp/brick_migrations"
-          is_insert_versions = false unless mig_path == mig_path2
-          if Dir.exist?(mig_path2)
-            if Dir["#{mig_path2}/**/*.rb"].present?
-              puts "As well, temporary folder #{mig_path2} also has ruby files present."
-              puts "Choose a destination -- all existing .rb files will be removed:"
-              mig_path2 = gets_list(list: ['Cancel operation!', "Append migration files into #{mig_path} anyway", mig_path, mig_path2])
-              return if mig_path2.start_with?('Cancel')
-
-              existing_mig_files = Dir["#{mig_path2}/**/*.rb"]
-              if (is_insert_versions = mig_path == mig_path2)
-                versions_to_delete_or_append = existing_mig_files.map { |ver| ver.split('/').last.split('_').first }
-              end
-              if mig_path2.start_with?('Append migration files into ')
-                mig_path2 = mig_path
-              else
-                is_delete_versions = true
-                existing_mig_files.each { |rb| File.delete(rb) }
-              end
-            else
-              puts "Using temporary folder #{mig_path2} for created migration files.\n\n"
-            end
-          else
-            puts "Creating the temporary folder #{mig_path2} for created migration files.\n\n"
-            Dir.mkdir(mig_path2)
-          end
-          mig_path = mig_path2
-        else
-          puts "Using standard migration folder #{mig_path} for created migration files.\n\n"
-        end
-      else
-        puts "Creating standard ActiveRecord migration folder #{mig_path} to hold new migration files.\n\n"
-        Dir.mkdir(mig_path)
-      end
+      mig_path, is_insert_versions, is_delete_versions = ::Brick::MigrationBuilder.check_folder
 
       # Generate a list of tables that can be chosen
       chosen = gets_list(list: tables, chosen: tables.dup)
-      schemas = chosen.each_with_object({}) do |v, s|
-        if (v_parts = v.split('.')).length > 1
-          s[v_parts.first] = nil unless [::Brick.default_schema, 'public'].include?(v_parts.first)
-        end
-      end
-      # Start the timestamps back the same number of minutes from now as expected number of migrations to create
-      current_mig_time = Time.now - (schemas.length + chosen.length).minutes
-      done = []
-      fks = {}
-      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.
-      versions_to_create = [] # Resulting versions to be used when updating the schema_migrations table
-      ar_base = Object.const_defined?(:ApplicationRecord) ? ApplicationRecord : Class.new(ActiveRecord::Base)
-      # 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
-      # no more migrations can be created.  (At that point hopefully all tables are accounted for.)
-      while (fringe = chosen.reject do |tbl|
-                        snag_fks = []
-                        snags = ::Brick.relations.fetch(tbl, nil)&.fetch(:fks, nil)&.select do |_k, v|
-                          v[:is_bt] && !v[:polymorphic] &&
-                          tbl != v[:inverse_table] && # Ignore self-referencing associations (stuff like "parent_id")
-                          !done.include?(v[:inverse_table]) &&
-                          ::Brick.config.ignore_migration_fks.exclude?(snag_fk = "#{tbl}.#{v[:fk]}") &&
-                          snag_fks << snag_fk
-                        end
-                        if snags&.present?
-                          # puts snag_fks.inspect
-                          stuck[tbl] = snags
-                        end
-                      end).present?
-        fringe.each do |tbl|
-          next unless (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
-
-          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ar_base.primary_key].flatten.sort)
-          # In case things aren't as standard
-          if pkey_cols.empty?
-            pkey_cols = if rpk.empty? && relation[:cols][arpk.first]&.first == key_type
-                          arpk
-                        elsif rpk.first
-                          rpk
-                        end
-          end
-          schema = if (tbl_parts = tbl.split('.')).length > 1
-                     if tbl_parts.first == (::Brick.default_schema || 'public')
-                       tbl_parts.shift
-                       nil
-                     else
-                       tbl_parts.first
-                     end
-                   end
-          unless schema.blank? || built_schemas.key?(schema)
-            mig = +"  def change\n    create_schema(:#{schema}) unless schema_exists?(:#{schema})\n  end\n"
-            migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time += 1.minute, ar_version, mig)
-            built_schemas[schema] = nil
-          end
 
-          # %%% For the moment we're skipping polymorphics
-          fkey_cols = relation[:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
-          # If the primary key is also used as a foreign key, will need to do  id: false  and then build out
-          # a column definition which includes :primary_key -- %%% also using a data type of bigserial or serial
-          # if this one has come in as bigint or integer.
-          pk_is_also_fk = fkey_cols.any? { |assoc| pkey_cols&.first == assoc[:fk] } ? pkey_cols&.first : nil
-          # Support missing primary key (by adding:  , id: false)
-          id_option = if pk_is_also_fk || !pkey_cols&.present?
-                        needs_serial_col = true
-                        +', id: false'
-                      elsif ((pkey_col_first = (col_def = relation[:cols][pkey_cols&.first])&.first) &&
-                             (pkey_col_first = SQL_TYPES[pkey_col_first] || SQL_TYPES[col_def&.[](0..1)] ||
-                                               SQL_TYPES.find { |r| r.first.is_a?(Regexp) && pkey_col_first =~ r.first }&.last ||
-                                               pkey_col_first
-                             ) != key_type
-                            )
-                        case pkey_col_first
-                        when 'integer'
-                          +', id: :serial'
-                        when 'bigint'
-                          +', id: :bigserial'
-                        else
-                          +", id: :#{pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
-                        end +
-                          (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
-                      end
-          if !id_option && pkey_cols.sort != arpk
-            id_option = +", primary_key: :#{pkey_cols.first}"
-          end
-          if !is_4x_rails && (comment = relation&.fetch(:description, nil))&.present?
-            (id_option ||= +'') << ", comment: #{comment.inspect}"
-          end
-          # Find the ActiveRecord class in order to see if the columns have comments
-          unless is_4x_rails
-            klass = begin
-                      tbl.tr('.', '/').singularize.camelize.constantize
-                    rescue StandardError
-                    end
-            if klass
-              unless ActiveRecord::Migration.table_exists?(klass.table_name)
-                puts "WARNING: Unable to locate table #{klass.table_name} (for #{klass.name})."
-                klass = nil
-              end
-            end
-          end
-          # Refer to this table name as a symbol or dotted string as appropriate
-          tbl_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
-          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
-          add_fks = [] # Track foreign keys to add after table creation
-          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
-            suffix = col_type[3] || pkey_cols&.include?(col) ? +', null: false' : +''
-            suffix << ', array: true' if (col_type.first == 'ARRAY')
-            if !is_4x_rails && klass && (comment = klass.columns_hash.fetch(col, nil)&.comment)&.present?
-              suffix << ", comment: #{comment.inspect}"
-            end
-            # Determine if this column is used as part of a foreign key
-            if (fk = fkey_cols.find { |assoc| col == assoc[:fk] })
-              to_table = fk[:inverse_table].split('.')
-              to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
-              if needs_serial_col && pkey_cols&.include?(col) && (new_serial_type = {'integer' => 'serial', 'bigint' => 'bigserial'}[sql_type])
-                sql_type = new_serial_type
-                needs_serial_col = false
-              end
-              if fk[:fk] != "#{fk[:assoc_name].singularize}_id" # Need to do our own foreign_key tricks, not use references?
-                column = fk[:fk]
-                mig << emit_column(sql_type, column, suffix)
-                add_fks << [to_table, column, ::Brick.relations[fk[:inverse_table]]]
-              else
-                suffix << ", type: :#{sql_type}" unless sql_type == key_type
-                # Will the resulting default index name be longer than what Postgres allows?  (63 characters)
-                if (idx_name = ActiveRecord::Base.connection.index_name(tbl, {column: col})).length > 63
-                  # Try to find a shorter name that hasn't been used yet
-                  unless indexes.key?(shorter = idx_name[0..62]) ||
-                         indexes.key?(shorter = idx_name.tr('_', '')[0..62]) ||
-                         indexes.key?(shorter = idx_name.tr('aeio', '')[0..62])
-                    puts "Unable to easily find unique name for index #{idx_name} that is shorter than 64 characters,"
-                    puts "so have resorted to this GUID-based identifier: #{shorter = "#{tbl[0..25]}_#{::SecureRandom.uuid}"}."
-                  end
-                  suffix << ", index: { name: '#{shorter || idx_name}' }"
-                  indexes[shorter || idx_name] = nil
-                end
-                primary_key = ::Brick.relations[fk[:inverse_table]][:class_name]&.constantize&.primary_key
-                mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table}#{", primary_key: :#{primary_key}" if primary_key != ar_base.primary_key} }\n"
-              end
-            else
-              next if !id_option&.end_with?('id: false') && pkey_cols&.include?(col)
-
-              # See if there are generic timestamps
-              if sql_type == 'timestamp' && ['created_at','updated_at'].include?(col)
-                possible_ts << [col, !col_type[3]]
-              else
-                mig << emit_column(sql_type, col, suffix)
-              end
-            end
-          end
-          if possible_ts.length == 2 && # Both created_at and updated_at
-             # Rails 5 and later timestamps default to NOT NULL
-             (possible_ts.first.last == is_4x_rails && possible_ts.last.last == is_4x_rails)
-            mig << "\n      t.timestamps\n"
-          else # Just one or the other, or a nullability mismatch
-            possible_ts.each { |ts| emit_column('timestamp', ts.first, nil) }
-          end
-          mig << "    end\n"
-          if pk_is_also_fk
-            mig << "    reversible do |dir|\n"
-            mig << "      dir.up { execute('ALTER TABLE #{tbl} ADD PRIMARY KEY (#{pk_is_also_fk})') }\n"
-            mig << "    end\n"
-          end
-          add_fks.each do |add_fk|
-            is_commented = false
-            # add_fk[2] holds the inverse relation
-            unless (pk = add_fk[2][:pkey].values.flatten&.first)
-              is_commented = true
-              mig << "    # (Unable to create relationship because primary key is missing on table #{add_fk[0]})\n"
-              # No official PK, but if coincidentally there's a column of the same name, take a chance on it
-              pk = (add_fk[2][:cols].key?(add_fk[1]) && add_fk[1]) || '???'
-            end
-            #                                                                 to_table               column
-            mig << "    #{'# ' if is_commented}add_foreign_key #{tbl_code}, #{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
-          end
-          mig << "  end\n"
-          versions_to_create << migration_file_write(mig_path, "create_#{tbl_parts.map(&:underscore).join('_')}", current_mig_time += 1.minute, ar_version, mig)
-        end
-        done.concat(fringe)
-        chosen -= done
-      end
-
-      stuck_counts = Hash.new { |h, k| h[k] = 0 }
-      chosen.each do |leftover|
-        puts "Can't do #{leftover} because:\n  #{stuck[leftover].map do |snag|
-          stuck_counts[snag.last[:inverse_table]] += 1
-          snag.last[:assoc_name]
-        end.join(', ')}"
-      end
-      if mig_path.start_with?(cur_path = ::Rails.root.to_s)
-        pretty_mig_path = mig_path[cur_path.length..-1]
-      end
-      puts "\n*** Created #{done.length} migration files under #{pretty_mig_path || mig_path} ***"
-      if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
-        puts "-----------------------------------------"
-        puts "Unable to create migrations for #{stuck_sorted.length} tables#{
-          ".  Here's the top 5 blockers" if stuck_sorted.length > 5
-        }:"
-        pp stuck_sorted[0..4]
-      else # Successful, and now we can update the schema_migrations table accordingly
-        unless ActiveRecord::Migration.table_exists?(ActiveRecord::Base.schema_migrations_table_name)
-          ActiveRecord::SchemaMigration.create_table
-        end
-        # Remove to_delete - to_create
-        if ((versions_to_delete_or_append ||= []) - versions_to_create).present? && is_delete_versions
-          ActiveRecord::Base.execute_sql("DELETE FROM #{
-            ActiveRecord::Base.schema_migrations_table_name} WHERE version IN (#{
-            (versions_to_delete_or_append - versions_to_create).map { |vtd| "'#{vtd}'" }.join(', ')}
-          )")
-        end
-        # Add to_create - to_delete
-        if is_insert_versions && ((versions_to_create ||= []) - versions_to_delete_or_append).present?
-          ActiveRecord::Base.execute_sql("INSERT INTO #{
-            ActiveRecord::Base.schema_migrations_table_name} (version) VALUES #{
-            (versions_to_create - versions_to_delete_or_append).map { |vtc| "('#{vtc}')" }.join(', ')
-          }")
-        end
-      end
-    end
-
-  private
-
-    def emit_column(type, name, suffix)
-      "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
-    end
-
-    def migration_file_write(mig_path, name, current_mig_time, ar_version, mig)
-      File.open("#{mig_path}/#{version = current_mig_time.strftime('%Y%m%d%H%M00')}_#{name}.rb", "w") do |f|
-        f.write "class #{name.camelize} < ActiveRecord::Migration#{ar_version}\n"
-        f.write mig
-        f.write "end\n"
-      end
-      version
+      ::Brick::MigrationBuilder.generate_migrations(chosen, mig_path, is_insert_versions, is_delete_versions)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.157
+  version: 1.0.160
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-27 00:00:00.000000000 Z
+date: 2023-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -255,6 +255,7 @@ files:
 - lib/brick/version_number.rb
 - lib/generators/brick/USAGE
 - lib/generators/brick/install_generator.rb
+- lib/generators/brick/migration_builder.rb
 - lib/generators/brick/migrations_generator.rb
 - lib/generators/brick/models_generator.rb
 - lib/generators/brick/seeds_generator.rb