brick 1.0.54 → 1.0.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09f9f2f9f7e21a96d29cdad815c069e52280ea068051f27a542541bcefd33e87'
-  data.tar.gz: 54e032633f930a43d1bc929d05d241367d9ebbdb8010f588b922d1111077524e
+  metadata.gz: 430a2dfa5ef0caee9b99bc341ccd42a9d29e8f1d54071284aa2469e1baa0c659
+  data.tar.gz: b36e18de169bd9032e6c383548ec30cce06eeb97a35e8c3e4f4da935aff8f603
 SHA512:
-  metadata.gz: 56cad221c2b20ac62839c1b7904c8acb9bc392b0779946bbe325c48c8ee5cf00b33413e070674343809ee851804e5f9bbec2d6469a148688c4aecbbcaee3e09d
-  data.tar.gz: 9757effb2a1d058ae4ccd259b59e0218e002928d90dadfd6ff3d0acd05fb12e27cfcfef30afa3964637e0e4f1e4246b410deba45fb01e452e20056df94820377
+  metadata.gz: c51491575b9ee56c3789619bfc74a2d9c0525750687224e94e120cbae42fad8db1abda9d82978115d9266c55fa0c6f914ce273a3613915657d8a0cf4e7fe6aeb
+  data.tar.gz: a0646cfdc9a2c844fd1149968d0175346c48835c6245d7fe92d0126d60708cf76514704e29dc3f506d2e06e546c8c995bf7103d6ef42be481bb931b4d2bfa73f

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 = 55
 
     # PRE is nil unless it's a pre-release (beta, RC, etc.)
     PRE = nil

data/lib/generators/brick/migrations_generator.rb

@@ -10,11 +10,17 @@ module Brick
     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'
+    # 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__)
@@ -38,24 +44,22 @@ 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")
+      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 = "#{File.expand_path(__dir__)}/tmp/brick_migrations"
+          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!', "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 ')
+              if mig_path2.start_with?('Append migration files into ')
                 mig_path2 = mig_path
               else
                 Dir["#{mig_path2}/**/*.rb"].each { |rb| File.delete(rb) }
@@ -78,7 +82,7 @@ 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 = {}
@@ -87,48 +91,110 @@ module Brick
       # 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 == '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"
+          # 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}" : '')
+                        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"
           possible_ts = [] # Track possible generic timestamps
-          (relation = ::Brick.relations[tbl])[:cols].each do |col, col_type|
-            next if pkey_cols.include?(col)
+          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
+            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' : +''
             # 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
+                mig << "      t.references :#{fk[:assoc_name]}#{suffix}, foreign_key: { to_table: #{to_table} }\n"
+              end
             else
-              mig << emit_column(sql_type, col)
+              mig << emit_column(sql_type, col, suffix)
             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  end\nend\n"
+          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}, #{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_#{tbl}.rb", "w") { |f| f.write mig }
+          File.open("#{mig_path}/#{current_mig_time.strftime('%Y%m%d%H%M00')}_create_#{full_table_name}.rb", "w") { |f| f.write mig }
         end
         done.concat(fringe)
         chosen -= done
@@ -140,7 +206,9 @@ 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__))
+      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} ***"
       if (stuck_sorted = stuck_counts.to_a.sort { |a, b| b.last <=> a.last }).length.positive?
         puts "-----------------------------------------"
@@ -153,8 +221,8 @@ module Brick
 
   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.55
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-08 00:00:00.000000000 Z
+date: 2022-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord