brick 1.0.55 → 1.0.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 430a2dfa5ef0caee9b99bc341ccd42a9d29e8f1d54071284aa2469e1baa0c659
-  data.tar.gz: b36e18de169bd9032e6c383548ec30cce06eeb97a35e8c3e4f4da935aff8f603
+  metadata.gz: 508d41fa8b75089e0467ece56ab53fc78b651f3951eabe62d108a62fa8b0f35e
+  data.tar.gz: dcd419560d850fb2014aab3076a6a80f5a555320ac2c2183e3381a916d94dbc8
 SHA512:
-  metadata.gz: c51491575b9ee56c3789619bfc74a2d9c0525750687224e94e120cbae42fad8db1abda9d82978115d9266c55fa0c6f914ce273a3613915657d8a0cf4e7fe6aeb
-  data.tar.gz: a0646cfdc9a2c844fd1149968d0175346c48835c6245d7fe92d0126d60708cf76514704e29dc3f506d2e06e546c8c995bf7103d6ef42be481bb931b4d2bfa73f
+  metadata.gz: 49c90c7fbb1845e151f91b9df7f3b639d587e6239dae5e7f31306807a2b4dc7ac83436d78d46839accfea7c614fd2a94f2460443ea3daae424d280fae17cac77
+  data.tar.gz: 7dd02fd9ab902cfe6359b6be95101ec3a89c47d8b7bc71692ab4537f5ffeb3a24a4ee73063fc10b3d4197ce59fd5c94380f7534f66647d8c03dd512c6ef0c334

data/lib/brick/version_number.rb

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

data/lib/generators/brick/migrations_generator.rb

@@ -5,12 +5,14 @@ require 'rails/generators/active_record'
 require 'fancy_gets'
 
 module Brick
-  # Auto-generates migrations
+  # Auto-generates migration files
   class MigrationsGenerator < ::Rails::Generators::Base
     include FancyGets
     # include ::Rails::Generators::Migration
 
-    # SQL types that are the same as their migration data type name:  text, integer, bigint, date, boolean, decimal, float
+    # 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',
@@ -23,15 +25,7 @@ module Brick
                   'smallint' => 'integer' } # %%% Need to put in "limit: 2"
     # (Still need to find what "inet" and "json" data types map to.)
 
-    # # source_root File.expand_path('templates', __dir__)
-    # class_option(
-    #   :with_changes,
-    #   type: :boolean,
-    #   default: false,
-    #   desc: 'Add IMPORT_TEMPLATE to model'
-    # )
-
-    desc 'Auto-generates migrations for an existing database.'
+    desc 'Auto-generates migration files for an existing database.'
 
     def brick_migrations
       # If Apartment is active, see if a default schema to analyse is indicated
@@ -47,11 +41,14 @@ module Brick
       key_type = (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
-      default_mig_path = (mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{::Rails.root}/db/migrate")
-      if Dir.exist?(mig_path)
+      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."
@@ -59,10 +56,15 @@ module Brick
               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
-                Dir["#{mig_path2}/**/*.rb"].each { |rb| File.delete(rb) }
+                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"
@@ -82,11 +84,21 @@ module Brick
 
       # 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|
+        schema = if v.split('.').length > 1
+                   v.first
+                 end
+        s[schema] = nil if schema && [::Brick.default_schema, 'public'].exclude?(schema)
+      end
       # Start the timestamps back the same number of minutes from now as expected number of migrations to create
-      current_mig_time = Time.now - chosen.length.minutes
+      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
       # 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.)
@@ -111,20 +123,28 @@ module Brick
                         end
           end
           schema = if (tbl_parts = tbl.split('.')).length > 1
-                     if tbl_parts.first == 'public'
+                     if tbl_parts.first == (::Brick.default_schema || 'public')
                        tbl_parts.shift
                        nil
                      else
                        tbl_parts.first
                      end
                    end
+          unless 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}", 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] }
-          mig = +"class Create#{(full_table_name = tbl_parts.join('_')).camelize} < ActiveRecord::Migration#{ar_version}\n"
+          # 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)
-          # also integer / uuid / other non-standard data types for primary key
-          id_option = unless (pkey_col_first = relation[:cols][pkey_cols&.first]&.first) == key_type
-                        unless pkey_cols&.present?
+          id_option = if pk_is_also_fk || (pkey_col_first = relation[:cols][pkey_cols&.first]&.first) != key_type
+                        if pk_is_also_fk || !pkey_cols&.present?
                           ', id: false'
                         else
                           case pkey_col_first
@@ -134,28 +154,36 @@ module Brick
                             ', id: :bigserial'
                           else
                             ", id: :#{SQL_TYPES[pkey_col_first] || pkey_col_first}" # Something like:  id: :integer, primary_key: :businessentityid
-                          end + (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '')
+                          end +
+                            (pkey_cols.first ? ", primary_key: :#{pkey_cols.first}" : '') +
+                            (!is_4x_rails && (comment = relation&.fetch(:description, nil))&.present? ? ", comment: #{comment.inspect}" : '')
                         end
                       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 = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
-          mig << "  def change\n    return unless reverting? || !table_exists?(#{tbl})\n\n"
-          mig << "    create_schema :#{schema} unless schema_exists?(:#{schema})\n" if schema
-          mig << "    create_table #{tbl}#{id_option} do |t|\n"
+          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|
-            next if !id_option&.end_with?('id: false') && pkey_cols.include?(col)
-
-            # See if there are generic timestamps
-            if (sql_type = SQL_TYPES[col_type.first]) == 'timestamp' &&
-               ['created_at','updated_at'].include?(col)
-              possible_ts << [col, !col_type[3]]
-              next
-            end
-
-            sql_type ||= col_type.first
+            sql_type = SQL_TYPES[col_type.first] || col_type.first
             suffix = col_type[3] ? +', null: false' : +''
+            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('.')
@@ -166,10 +194,29 @@ module Brick
                 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
                 mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table} }\n"
               end
             else
-              mig << emit_column(sql_type, col, suffix)
+              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
@@ -180,6 +227,11 @@ module Brick
             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
@@ -189,16 +241,16 @@ module Brick
               # 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}, #{add_fk[0]}, column: :#{add_fk[1]}, primary_key: :#{pk}\n"
+            #                                                                 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\nend\n"
-          current_mig_time += 1.minute
-          File.open("#{mig_path}/#{current_mig_time.strftime('%Y%m%d%H%M00')}_create_#{full_table_name}.rb", "w") { |f| f.write mig }
+          mig << "  end\n"
+          versions_to_create << migration_file_write(mig_path, "create_#{tbl_parts.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|
@@ -209,13 +261,31 @@ module Brick
       if mig_path.start_with?(cur_path = ::Rails.root.to_s)
         pretty_mig_path = mig_path[cur_path.length..-1]
       end
-      puts "*** Created #{done.length} migration files under #{pretty_mig_path || mig_path} ***"
+      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
 
@@ -224,5 +294,14 @@ module Brick
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.55
+  version: 1.0.58
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-09 00:00:00.000000000 Z
+date: 2022-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord