brick 1.0.53 → 1.0.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 737256fad5c987fa2ac603cf3708da959127a33ab9b27d164ceff858b71987b9
-  data.tar.gz: 144352db7686d19d9c330887069287da88de456276cc17aaeeaeb3c1de7a3281
+  metadata.gz: b696c53c9d9d359d49de147b06b5342820ca230451c860d097f44bcae3b23bb0
+  data.tar.gz: 7b0f6ff365f918a97d64305eabf70fcfe78cf764514ca22b3731b780da04b22c
 SHA512:
-  metadata.gz: 83ec370e06c18bf9d62ec3ed445daf78dc5cbff825a85ff017cc7b814efb62f86e68022f7577734dd01ddf7e2f74b4b59de4b40b9c07656e83d0859ba6a4333d
-  data.tar.gz: 9106373ca7878dcc75c596f1fa44d420980c50cb09f5b63a1110d4e02dc63f02dafe3d1bc0d4de38a75d5678d964e3b8f12a720a722d2f593934e2f6be97f818
+  metadata.gz: 43ab6db28554fb7502d0f03267d2f5bab27d310fb988701d371232f6604090cd679767a12097a7c217401b05e938c787844ae11138a2c8143c1e675b93599656
+  data.tar.gz: 8d2e592ba27bba30e100ea23a2bf951d6f3861c422ef355bad7cd38e146c20c2cf53380aa7ee440f40aa2d111c7f33eadc8dc09f73d1689432fff071e04228c4

data/lib/brick/extensions.rb

@@ -1289,7 +1289,10 @@ module ActiveRecord::ConnectionHandling
   alias _brick_establish_connection establish_connection
   def establish_connection(*args)
     conn = _brick_establish_connection(*args)
-    _brick_reflect_tables
+    begin
+      _brick_reflect_tables
+    rescue ActiveRecord::NoDatabaseError
+    end
     conn
   end
 
@@ -1313,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'
@@ -1339,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 = 53
+    TINY = 56
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/generators/brick/install_generator.rb

@@ -7,13 +7,13 @@ module Brick
   class InstallGenerator < ::Rails::Generators::Base
     # include ::Rails::Generators::Migration
 
-    source_root File.expand_path('templates', __dir__)
-    class_option(
-      :with_changes,
-      type: :boolean,
-      default: false,
-      desc: 'Store changeset (diff) with each version'
-    )
+    # source_root File.expand_path('templates', __dir__)
+    # class_option(
+    #   :with_changes,
+    #   type: :boolean,
+    #   default: false,
+    #   desc: 'Store changeset (diff) with each version'
+    # )
 
     desc 'Generates an initializer file for configuring Brick'
 

data/lib/generators/brick/migrations_generator.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'fancy_gets'
+
+module Brick
+  # Auto-generates migrations
+  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
+    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.'
+
+    def brick_migrations
+      # If Apartment is active, see if a default schema to analyse is indicated
+
+      # # Load all models
+      # Rails.configuration.eager_load_namespaces.select { |ns| ns < Rails::Application }.each(&:eager_load!)
+
+      if (tables = ::Brick.relations.reject { |k, v| v.key?(:isView) && v[:isView] == true }.map(&:first).sort).empty?
+        puts "No tables found in database #{ActiveRecord::Base.connection.current_database}."
+        return
+      end
+
+      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)
+        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"
+          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')
+
+              if mig_path2.start_with?('Append migration files into ')
+                mig_path2 = mig_path
+              else
+                Dir["#{mig_path2}/**/*.rb"].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
+
+      # Generate a list of tables that can be chosen
+      chosen = gets_list(list: tables, chosen: tables.dup)
+      # 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
+      versions = [] # 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.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?
+                      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 = [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 == 'public'
+                       tbl_parts.shift
+                       nil
+                     else
+                       tbl_parts.first
+                     end
+                   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"
+          # 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: 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 schema_exists?(:#{schema})\n" if schema
+          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
+            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('.')
+              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, suffix)
+            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"
+          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\nend\n"
+          current_mig_time += 1.minute
+          versions << (version = current_mig_time.strftime('%Y%m%d%H%M00'))
+          File.open("#{mig_path}/#{version}_create_#{full_table_name}.rb", "w") { |f| f.write 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
+        ActiveRecord::Base.execute_sql("INSERT INTO #{ActiveRecord::Base.schema_migrations_table_name} (version) VALUES #{
+          versions.map { |version| "('#{version}')" }.join(', ')
+        }")
+      end
+    end
+
+  private
+
+    def emit_column(type, name, suffix)
+      "      t.#{type.start_with?('numeric') ? 'decimal' : type} :#{name}#{suffix}\n"
+    end
+  end
+end

data/lib/generators/brick/model_generator.rb

@@ -59,7 +59,6 @@ module Brick
         end
       end
       models.each do |m| # Find longest name in the list for future use to show lists on the right side of the screen
-        # Strangely this can't be inlined since it assigns to "len"
         if longest_length < (len = m.name.length)
           longest_length = len
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.53
+  version: 1.0.56
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-07 00:00:00.000000000 Z
+date: 2022-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -238,6 +238,7 @@ files:
 - lib/brick/version_number.rb
 - lib/generators/brick/USAGE
 - lib/generators/brick/install_generator.rb
+- lib/generators/brick/migrations_generator.rb
 - lib/generators/brick/model_generator.rb
 - lib/generators/brick/templates/add_object_changes_to_versions.rb.erb
 - lib/generators/brick/templates/create_versions.rb.erb