brick 1.0.203 → 1.0.204

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7653a7b2f496e0ade8937b6352b66d06a63dc47487a2472ebf5e5f5b94faf711
-  data.tar.gz: b4723c7d202d7cdaf125bd0ca6bc52852b89c813444bf8e4662724a591d7a7bc
+  metadata.gz: 9bf1dd73cdb0040884c92622e0a7dab4c36232440b5f70e74c2f9f362843373d
+  data.tar.gz: 19fd7bbfd6088ed1606b6c2a5ad2fa67cb9dd3b6217313bdfaa368b4fc1ca5f0
 SHA512:
-  metadata.gz: c29614452bbbd5b1c52e6fcee20fd2308479e508a03d15d98ddd3ca73c3ad746dff9e9bfffb8979768f456d68ce5bbfaa286d96c2ef62c65e306bd3d0fa15495
-  data.tar.gz: f8a2ac34c8a34a3a7308a49b6e17a57bf71c13718a58838f61e8e5d45699f3d9dee766a3786d4fd11be52601f02e9168803f49a8b4ce35ef7d404bef95523584
+  metadata.gz: eb16cd17c3ad18718164242957e71353ccb5708650136a44517a13255b65d40dc47d6b579defd92d76b9b6a77c696a386880db70f6c2d1495a0f198f64866dbc
+  data.tar.gz: 97e22cd5f88a8008313362558ccb5ab7829772568573f0622e2eba61640d5a59ae44135d4870878f90bd750d496ed8aeef0e22badffe4168b142580911650b11

data/lib/brick/extensions.rb

@@ -126,10 +126,11 @@ module ActiveRecord
         return @_brick_primary_key if instance_variable_defined?(:@_brick_primary_key)
 
         pk = begin
-              primary_key.is_a?(String) ? [primary_key] : primary_key.dup || []
-            rescue
-              []
-            end
+               primary_key
+             rescue
+               superclass.respond_to?(:primary_key) && superclass.primary_key
+             end
+        pk = pk.is_a?(String) ? [pk] : pk.dup || []
         pk.map! { |pk_part| pk_part =~ /^[A-Z0-9_]+$/ ? pk_part.downcase : pk_part } unless connection.adapter_name == 'MySQL2'
         # Just return [] if we're missing any part of the primary key.  (PK is usually just "id")
         if relation && pk.present?
@@ -1551,7 +1552,7 @@ class Object
 
   private
 
-    def build_model(relations, base_module, base_name, class_name, inheritable_name = nil)
+    def build_model(relations, base_module, base_name, class_name, inheritable_name = nil, is_generator = nil)
       tnp = ::Brick.config.table_name_prefixes&.find { |p| p.last == base_module.name }
       # return [base_module, ''] if !base_module.is_a?(Class) && base_name == tnp&.last
 
@@ -1585,12 +1586,12 @@ class Object
         # Maybe, just maybe there's a database table that will satisfy this need
         matching = ::Brick.table_name_lookup&.fetch(class_name, nil)
         if (matching ||= [table_name, singular_table_name, plural_class_name, model_name, table_name.titleize].find { |m| relations.key?(schema_name ? "#{schema_name}.#{m}" : m) })
-          build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
+          build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching, is_generator)
         end
       end
     end
 
-    def build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching)
+    def build_model_worker(schema_name, inheritable_name, model_name, singular_table_name, table_name, relations, matching, is_generator = nil)
       if ::Brick.apartment_multitenant &&
          schema_name == ::Brick.apartment_default_tenant
         relation = relations["#{schema_name}.#{matching}"]
@@ -1638,11 +1639,11 @@ class Object
       hmts = nil
       if (schema_module || Object).const_defined?((chosen_name = (inheritable_name || model_name)).to_sym)
         possible = (schema_module || Object).const_get(chosen_name)
-        return possible unless possible == schema_module
+        return possible unless possible == schema_module || is_generator
       end
       code = +"class #{full_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
-        (schema_module || Object).const_set(chosen_name, new_model_class)
+        (schema_module || Object).const_set(chosen_name, new_model_class) unless is_generator
         @_brick_relation = relation
         if inheritable_name
           new_model_class.define_singleton_method :inherited do |subclass|
@@ -1662,7 +1663,7 @@ class Object
           code << "  has_secure_password\n"
         end
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
-        code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || self.table_name != matching
+        code << "  self.table_name = '#{self.table_name = matching}'\n" if (inheritable_name || model_name).underscore.pluralize != matching
         if (inh_col = ::Brick.config.sti_type_column.find { |_k, v| v.include?(matching) }&.first)
           new_model_class.inheritance_column = inh_col
           code << "  self.inheritance_column = '#{inh_col}'\n"
@@ -2618,9 +2619,9 @@ class Object
 
     def _brick_get_hm_assoc_name(relation, hm_assoc, source = nil)
       assoc_name, needs_class = if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
-                                   hm_assoc[:alternate_name] != (source || name.underscore)
+                                   hm_assoc[:alternate_name] != (source || name&.underscore)
                                   plural = "#{hm_assoc[:assoc_name]}_#{ActiveSupport::Inflector.pluralize(hm_assoc[:alternate_name])}"
-                                  new_alt_name = (hm_assoc[:alternate_name] == name.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
+                                  new_alt_name = (hm_assoc[:alternate_name] == name&.underscore) ? "#{hm_assoc[:assoc_name].singularize}_#{plural}" : plural
                                   # %%% In rare cases might even need to add a number at the end for uniqueness
                                   # uniq = 1
                                   # while same_name = relation[:fks].find { |x| x.last[:assoc_name] == hm_assoc[:assoc_name] && x.last != hm_assoc }
@@ -3008,9 +3009,14 @@ module Brick
 
     def _brick_index(tbl_name, mode = nil, separator = nil, relation = nil, not_path = nil)
       separator ||= '_'
-      res_name = (tbl_name_parts = tbl_name.split('.'))[0..-2].first
-      res_name << '.' if res_name
-      (res_name ||= +'') << (relation ||= ::Brick.relations.fetch(tbl_name, nil))&.fetch(:resource, nil) || tbl_name_parts.last
+      relation ||= ::Brick.relations.fetch(tbl_name, nil)
+      if mode == :migration
+        res_name = tbl_name
+      else
+        res_name = (tbl_name_parts = tbl_name.split('.'))[0..-2].first
+        res_name << '.' if res_name
+        (res_name ||= +'') << relation&.fetch(:resource, nil) || tbl_name_parts.last
+      end
 
       res_parts = ((mode == :singular) ? res_name.singularize : res_name).split('.')
       res_parts.shift if ::Brick.apartment_multitenant && res_parts.length > 1 && res_parts.first == ::Brick.apartment_default_tenant

data/lib/brick/version_number.rb

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

data/lib/generators/brick/controllers_generator.rb

@@ -34,7 +34,6 @@ module Brick
 
         tbl_parts = rel.first.split('.')
         tbl_parts.shift if [::Brick.default_schema, 'public'].include?(tbl_parts.first)
-        tbl_parts[-1] = tbl_parts[-1].pluralize
         begin
           s << ControllerOption.new(tbl_parts.join('/').camelize, rel.last[:class_name].constantize)
         rescue
@@ -64,7 +63,7 @@ module Brick
                     else
                       Object
                     end
-        controller_parts[controller_parts.length - 1] = (controller_name = "#{controller_parts.last.pluralize}Controller")
+        controller_parts[controller_parts.length - 1] = (controller_name = "#{controller_parts.last}Controller")
         _built_controller, code = Object.send(:build_controller, namespace, controller_name, controller_name, controller_option.model, relations)
         path = ['controllers']
         path.concat(controller_parts.map(&:underscore))

data/lib/generators/brick/migration_builder.rb

@@ -110,7 +110,7 @@ module Brick
           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
+        current_mig_time = [Time.now - (schemas.length + chosen.length).minutes]
         done = []
         fks = {}
         stuck = {}
@@ -139,12 +139,14 @@ module Brick
                             # puts snag_fks.inspect
                             stuck[tbl] = snags
                           end
-                        end).present?
+                        end
+              ).present?
           fringe.each do |tbl|
             mig = gen_migration_columns(relations, tbl, (tbl_parts = tbl.split('.')), (add_fks = []), built_schemas, mig_path, current_mig_time,
-                                        key_type, is_4x_rails, ar_version, do_fks_last)
+                                        key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
             after_fks.concat(add_fks) if do_fks_last
-            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, 'x')}", current_mig_time += 1.minute, ar_version, mig)
+            current_mig_time[0] += 1.minute
+            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, 'x')}", current_mig_time, ar_version, mig)
           end
           done.concat(fringe)
           chosen -= done
@@ -154,9 +156,10 @@ module Brick
           # Write out any more tables that haven't been done yet
           chosen.each do |tbl|
             mig = gen_migration_columns(relations, tbl, (tbl_parts = tbl.split('.')), (add_fks = []), built_schemas, mig_path, current_mig_time,
-                                        key_type, is_4x_rails, ar_version, do_fks_last)
+                                        key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
             after_fks.concat(add_fks)
-            migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, nil, 'x')}", current_mig_time += 1.minute, ar_version, mig)
+            current_mig_time[0] += 1.minute
+            versions_to_create << migration_file_write(mig_path, "create_#{::Brick._brick_index(tbl, :migration, 'x')}", current_mig_time, ar_version, mig)
           end
           done.concat(chosen)
           chosen.clear
@@ -188,7 +191,8 @@ module Brick
     end\n"
             end
             mig << +"  end\n"
-            migration_file_write(mig_path, 'create_brick_fks.rbx', current_mig_time += 1.minute, ar_version, mig)
+            current_mig_time[0] += 1.minute
+            versions_to_create << migration_file_write(mig_path, 'create_brick_fks.rbx', current_mig_time, ar_version, mig)
             puts "Have written out a final migration called 'create_brick_fks.rbx' which creates #{after_fks.length} foreign keys.
   This file extension (.rbx) will cause it not to run yet when you do a 'rails db:migrate'.
   The idea here is to do all data loading first, and then rename that migration file back
@@ -255,7 +259,7 @@ module Brick
     private
 
       def gen_migration_columns(relations, tbl, tbl_parts, add_fks, built_schemas, mig_path, current_mig_time,
-                                key_type, is_4x_rails, ar_version, do_fks_last)
+                                key_type, is_4x_rails, ar_version, do_fks_last, versions_to_create)
         return unless (relation = relations.fetch(tbl, nil))&.fetch(:cols, nil)&.present?
 
         mig = +''
@@ -278,7 +282,8 @@ module Brick
                  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)
+          current_mig_time[0] += 1.minute
+          versions_to_create << migration_file_write(mig_path, "create_db_schema_#{schema.underscore}", current_mig_time, ar_version, mig)
           built_schemas[schema] = nil
         end
 
@@ -389,11 +394,11 @@ module Brick
           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)
+           # 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) }
+          possible_ts.each { |ts| mig << emit_column('timestamp', ts.first, nil) }
         end
         mig << "    end\n"
         if pk_is_also_fk
@@ -424,7 +429,7 @@ module Brick
       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' unless name.index('.')}", "w") do |f|
+        File.open("#{mig_path}/#{version = current_mig_time.first.strftime('%Y%m%d%H%M00')}_#{name}#{'.rb' unless name.index('.')}", "w") do |f|
           f.write "class #{name.split('.').first.camelize} < ActiveRecord::Migration#{ar_version}\n"
           f.write mig
           f.write "end\n"

data/lib/generators/brick/models_generator.rb

@@ -62,7 +62,7 @@ module Brick
                       else
                         Object
                       end
-        _built_model, code = Object.send(:build_model, relations, base_module, base_module.name, model_parts.last)
+        _built_model, code = Object.send(:build_model, relations, base_module, base_module.name, model_parts.last, nil, true)
         path = ['models']
         path.concat(model_parts.map(&:underscore))
         dir = +"#{::Rails.root}/app"

data/lib/generators/brick/seeds_generator.rb

@@ -27,7 +27,7 @@ module Brick
       # Generate a list of viable models that can be chosen
       # First start with any existing models that have been defined ...
       existing_models = ActiveRecord::Base.descendants.each_with_object({}) do |m, s|
-        s[m.table_name] = SeedModel.new(m.table_name, m, false) if !m.abstract_class? && m.table_exists?
+        s[m.table_name] = SeedModel.new(m.table_name, m, false) if !m.abstract_class? && !m.is_view? && m.table_exists?
       end
       models = (existing_models.values +
                 # ... then add models which can be auto-built by Brick
@@ -123,12 +123,15 @@ module Brick
             pk_val = obj.send(pkey_cols.first)
             fk_vals = []
             data = []
-            relation[:cols].each do |col, col_type|
+            relation[:cols].each do |col, _col_type|
               next if !(fk = fkeys.find { |assoc| col == assoc[:fk] }) &&
                       pkey_cols.include?(col)
 
-              if (val = obj.send(col)) && (val.is_a?(Time) || val.is_a?(Date))
-                val = val.to_s
+              begin
+                if (val = obj.send(col)) && (val.is_a?(Time) || val.is_a?(Date))
+                  val = val.to_s
+                end
+              rescue StandardError => e # ActiveRecord::Encryption::Errors::Configuration
               end
               if fk
                 inv_tbl = fk[:inverse_table].gsub('.', '__')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.203
+  version: 1.0.204
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-07 00:00:00.000000000 Z
+date: 2024-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord