brick 1.0.54 → 1.0.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09f9f2f9f7e21a96d29cdad815c069e52280ea068051f27a542541bcefd33e87'
-  data.tar.gz: 54e032633f930a43d1bc929d05d241367d9ebbdb8010f588b922d1111077524e
+  metadata.gz: 930370b67a72b31db99cc8d50afa80d4c3be0d07e727155eb20ac5a7628bb1bb
+  data.tar.gz: f2d7964c79172a438800b3c69c63e62b26a4984357ca5d6c7ff9e2ef72e5308f
 SHA512:
-  metadata.gz: 56cad221c2b20ac62839c1b7904c8acb9bc392b0779946bbe325c48c8ee5cf00b33413e070674343809ee851804e5f9bbec2d6469a148688c4aecbbcaee3e09d
-  data.tar.gz: 9757effb2a1d058ae4ccd259b59e0218e002928d90dadfd6ff3d0acd05fb12e27cfcfef30afa3964637e0e4f1e4246b410deba45fb01e452e20056df94820377
+  metadata.gz: 03e7ba018c426517060aa6312d14a9f1e0877d82b376782ea46b4b1506433bbe3e9e4d2c3d88aaf3d5fb356c68a129fd975b1718d7b2ac826b241efab3f2cee6
+  data.tar.gz: 645c6b750dd870180e312ffddff1d199bb84e92cdde0309f253ec8c927f3ba5304b84ae95b066c260d0523048c607b28148d1b577a479ec661b94de05248813a

data/lib/brick/extensions.rb

@@ -1316,16 +1316,21 @@ module ActiveRecord::ConnectionHandling
       # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
       is_postgres = nil
-      schema_sql = 'SELECT NULL AS table_schema;'
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
         is_postgres = true
+        db_schemas = ActiveRecord::Base.execute_sql('SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;')
+        ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
+          row = row.is_a?(String) ? row : row['table_schema']
+          # Remove any system schemas
+          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
+        end
         if (is_multitenant = (multitenancy = ::Brick.config.schema_behavior[:multitenant]) &&
-           (sta = multitenancy[:schema_to_analyse]) != 'public')
+           (sta = multitenancy[:schema_to_analyse]) != 'public') &&
+           ::Brick.db_schemas.include?(sta)
           ::Brick.default_schema = schema = sta
           ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
         end
-        schema_sql = 'SELECT DISTINCT table_schema FROM INFORMATION_SCHEMA.tables;'
       when 'Mysql2'
         ::Brick.default_schema = schema = ActiveRecord::Base.connection.current_database
       when 'SQLite'
@@ -1342,16 +1347,7 @@ module ActiveRecord::ConnectionHandling
         puts "Unfamiliar with connection adapter #{ActiveRecord::Base.connection.adapter_name}"
       end
 
-      unless (db_schemas = ActiveRecord::Base.execute_sql(schema_sql)).is_a?(Array)
-        db_schemas = db_schemas.to_a
-      end
-      unless db_schemas.empty?
-        ::Brick.db_schemas = db_schemas.each_with_object({}) do |row, s|
-          row = row.is_a?(String) ? row : row['table_schema']
-          # Remove any system schemas
-          s[row] = nil unless ['information_schema', 'pg_catalog'].include?(row)
-        end
-      end
+      ::Brick.db_schemas ||= []
 
       if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
         if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))

data/lib/brick/version_number.rb

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

data/lib/generators/brick/migrations_generator.rb

@@ -5,27 +5,27 @@ 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, smallint, date, boolean, decimal, float
-    SQL_TYPES = { 'character varying' =>'string',
-                  'timestamp without time zone' =>'timestamp',
-                  'timestamp with time zone' =>'timestamp',
-                  'double precision' =>'float' } # might work with 'double'
+    # 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', # might work with 'double'
+                  '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
@@ -38,27 +38,33 @@ module Brick
         return
       end
 
-      ar_version = unless ActiveRecord.version < ::Gem::Version.new('5.0')
-                     arv = ActiveRecord.version.segments[0..1]
-                     arv.pop if arv&.last == 0
-                     "[#{arv.join('.')}]"
-                   end
-      default_mig_path = (mig_path = ActiveRecord::Migrator.migrations_paths.first || "#{File.expand_path(__dir__)}/db/migrate")
-      if Dir.exist?(mig_path)
+      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
+      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 = "#{File.expand_path(__dir__)}/tmp/brick_migrations"
+          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!', "Add all migration files to #{mig_path} anyway", mig_path, mig_path2])
+              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')
 
-              if mig_path2.start_with?('Add all migration files to ')
+              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"
@@ -78,57 +84,160 @@ module Brick
 
       # Generate a list of tables that can be chosen
       chosen = gets_list(list: tables, chosen: tables.dup)
-      # Work from now back the same number of minutes as expected migrations to create
+      # 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
       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.)
       while (fringe = chosen.reject do |tbl|
-                        snags = ::Brick.relations[tbl][:fks].select do |_k, v|
+                        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])
                         end
-                        stuck[tbl] = snags if snags.present?
+                        stuck[tbl] = snags if snags&.present?
                       end).present?
         fringe.each do |tbl|
-          tbl = tbl[7..-1] if tbl.start_with?('public.') # %%% Provide better multitenancy support later
-          pkey_cols = ::Brick.relations[chosen.first][:pkey].values.flatten
+          next unless (relation = ::Brick.relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
+
+          pkey_cols = (rpk = relation[:pkey].values.flatten) & (arpk = [ActiveRecord::Base.primary_key].flatten)
+          # 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
           # %%% For the moment we're skipping polymorphics
-          fkey_cols = ::Brick.relations[tbl][:fks].values.select { |assoc| assoc[:is_bt] && !assoc[:polymorphic] }
-          mig = +"class Create#{table_name = tbl.camelize} < ActiveRecord::Migration#{ar_version}\n"
-          # %%% Support missing foreign key (by adding:  ,id: false)
-          # also bigint / uuid / other non-standard data type for primary key
-          mig << "  def change\n    create_table :#{tbl} do |t|\n"
+          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)
+          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
+                          when 'integer'
+                            ', id: :serial'
+                          when 'bigint'
+                            ', 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}" : '') +
+                            (!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_code = tbl_parts.length == 1 ? ":#{tbl_parts.first}" : "'#{tbl}'"
+          mig << "  def change\n    return unless reverting? || !table_exists?(#{tbl_code})\n\n"
+          mig << "    create_schema :#{schema} unless reverting? || schema_exists?(:#{schema})\n" if schema
+          mig << "    create_table #{tbl_code}#{id_option} do |t|\n"
           possible_ts = [] # Track possible generic timestamps
-          (relation = ::Brick.relations[tbl])[:cols].each do |col, col_type|
-            next if 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
-              next
+          add_fks = [] # Track foreign keys to add after table creation
+          relation[:cols].each do |col, col_type|
+            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
-
-            sql_type ||= col_type.first
             # Determine if this column is used as part of a foreign key
             if fk = fkey_cols.find { |assoc| col == assoc[:fk] }
-              mig << "      t.references :#{fk[:assoc_name]}#{", type: #{sql_type}" unless sql_type == 'integer'}\n"
+              to_table = fk[:inverse_table].split('.')
+              to_table = to_table.length == 1 ? ":#{to_table.first}" : "'#{fk[:inverse_table]}'"
+              if fk[:fk] != "#{fk[:assoc_name].singularize}_id" # Need to do our own foreign_key tricks, not use references?
+                column = fk[:fk]
+                mig << "      t.#{sql_type} :#{column}#{suffix}\n"
+                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)
+              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
+          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
-            possible_ts.each { |ts| emit_column('timestamp', ts) }
+          else # Just one or the other, or a nullability mismatch
+            possible_ts.each { |ts| emit_column('timestamp', ts.first, nil) }
+          end
+          mig << "    end\n"
+          mig << "    execute('ALTER TABLE #{tbl} ADD PRIMARY KEY (#{pk_is_also_fk});')\n" if pk_is_also_fk
+          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
+          unless built_schemas.key?(schema)
+            mig << "    drop_schema :#{schema} if reverting? && schema_exists?(:#{schema})\n"
+            built_schemas[schema] = nil
           end
-          mig << "    end\n  end\nend\n"
+          mig << "  end\nend\n"
           current_mig_time += 1.minute
-          File.open("#{mig_path}/#{current_mig_time.strftime('%Y%m%d%H%M00')}_create_#{tbl}.rb", "w") { |f| f.write mig }
+          versions_to_create << (version = current_mig_time.strftime('%Y%m%d%H%M00')).split('_').first
+          File.open("#{mig_path}/#{version}_create_#{full_table_name}.rb", "w") { |f| f.write mig }
         end
         done.concat(fringe)
         chosen -= done
@@ -140,21 +249,41 @@ module Brick
           snag.last[:assoc_name]
         end.join(', ')}"
       end
-      pretty_mig_path = mig_path[cur_path.length] if mig_path.start_with?(cur_path = File.expand_path(__dir__))
-      puts "*** Created #{done.length} migration files under #{pretty_mig_path || mig_path} ***"
+      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)
-      "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}\n"
+    def emit_column(type, name, suffix)
+      "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
     end
   end
 end

metadata

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