brick 1.0.157 → 1.0.158

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 995a300b0971af02a39ed75857ce349c99720068555cbb1d6311a75d9a13f2b8
-  data.tar.gz: e9153dac19552fc8dd581774f89b9ed682ac040b5a4dc0d47f4b28fe079ca36d
+  metadata.gz: 326ec09b1c28cf7c54e54bae9ea6ceed7d7e476a177be0a41af14e04f7cc3d11
+  data.tar.gz: 0507c22a2acf86c58737ecfedeb1a1f5ed6979b5263b28c6d6e77b0e9500ab7c
 SHA512:
-  metadata.gz: 4c0c8553d5ef266aa6e947d6f0dd9ee4ae23d64118cd3c69565345747be0afa4de63be999976bd8e4fed55ebec2f3551aa87a4f4b84dee0a3dced188d23260f6
-  data.tar.gz: a7e0dbdd27c5d0905d7acf0a7a3f6fb5e254556ef65a0633a3021c395664c65f152afd3cecc53992c0f5da0095a1246b10d14898c34d82c60fc1cec298e62a68
+  metadata.gz: d6803593a5c3e17ef40005c405017ed4e7519024ca172a077ad377c201a7b2e2caf2a8b4bc5a0ef63f091124a44199ffd3b386db7d6b5d51352f2e3327537d81
+  data.tar.gz: 486b0a15422b0d3150b575c8d19c24cc3434e3fd8f35335d2e490e1e69e423995a2032de913def73b4f4df0e2789c6f4af7d61930db5cc144d0a0cb76be3ebdc

data/lib/brick/extensions.rb

@@ -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
@@ -2310,7 +2317,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits_txt = model._brick_find_permits(model, permits = model.columns_hash.keys.map(&:to_sym))
+            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields)
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
             code << "  end\n"

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

@@ -713,12 +713,9 @@ window.addEventListener(\"popstate\", linkSchemas);
                                  next unless @_brick_model.instance_methods.include?(through) &&
                                              (associative = @_brick_model._br_associatives.fetch(hm.first, nil))
 
-                                 tbl_nm = if (source = hm_assoc.source_reflection).macro == :has_many
-                                            source.inverse_of&.name # For HM -> HM style HMT
-                                          else # belongs_to or has_one
-                                            hm_assoc.through_reflection&.name # for standard HMT, which is HM -> BT
-                                          end
-                                 # If there is no inverse available for the source belongs_to association, make one based on the class name
+                                 # Should handle standard HMT, which is HM -> BT, as well as HM -> HM style HMT
+                                 tbl_nm = hm_assoc.source_reflection&.inverse_of&.name
+                                 # If there is no inverse available for the source belongs_to association, infer one based on the class name
                                  unless tbl_nm
                                    tbl_nm = associative.class_name.underscore
                                    tbl_nm.slice!(0) if tbl_nm[0] == '/'
@@ -1679,12 +1676,22 @@ end
          @#{obj_name}.send(\"#\{model.brick_foreign_type(v.first)}=\", v[1].first&.first&.name)
        end
      end if @#{obj_name}.new_record?
-     @#{obj_name}.attributes.each do |k, val|
-       next if !(col = #{model_name}.columns_hash[k]) ||
-               (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
-               ::Brick.config.metadata_columns.include?(k) %>
+     rtans = #{model_name}.rich_text_association_names if #{model_name}.respond_to?(:rich_text_association_names)
+     (#{model_name}.column_names + (rtans || [])).each do |k|
+       next if (#{(pk.map(&:to_s) || []).inspect}.include?(k) && !bts.key?(k)) ||
+               ::Brick.config.metadata_columns.include?(k)
+
+       col = #{model_name}.columns_hash[k]
+       if !col && rtans&.include?(k)
+         k = k[10..-1] if k.start_with?('rich_text_')
+         col = (rt_col ||= ActiveRecord::ConnectionAdapters::Column.new(
+                             '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: 'varchar', type: :text)
+                           )
+               )
+       end
+       val = @#{obj_name}.attributes[k] %>
     <tr>
-    <th class=\"show-field\"<%= \" title=\\\"#\{col.comment}\\\"\".html_safe if col.respond_to?(:comment) && !col.comment.blank? %>>
+    <th class=\"show-field\"<%= \" title=\\\"#\{col&.comment}\\\"\".html_safe if col&.respond_to?(:comment) && !col&.comment.blank? %>>
 <%    has_fields = true
       if (bt = bts[k])
         # Add a final member in this array with descriptive options to be used in <select> drop-downs
@@ -1716,7 +1723,7 @@ end
           collection&.brick_(:each) do |obj|
             option_detail << [
               obj.brick_descrip(
-                descrip_cols&.first&.map { |col| obj.send(col.last) },
+                descrip_cols&.first&.map { |col2| obj.send(col2.last) },
                 obj_pk
               ), obj.send(obj_pk)
             ]

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)
@@ -100,7 +107,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"

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 157
+    TINY = 158
 
     # 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"

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,341 @@
+module Brick
+  module MigrationBuilder
+    # 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,13 @@
 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 +24,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.158
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-27 00:00:00.000000000 Z
+date: 2023-07-29 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