brick 1.0.203 → 1.0.205

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7653a7b2f496e0ade8937b6352b66d06a63dc47487a2472ebf5e5f5b94faf711
-  data.tar.gz: b4723c7d202d7cdaf125bd0ca6bc52852b89c813444bf8e4662724a591d7a7bc
+  metadata.gz: 3abdf25aeb401676febcc1ea98ce104a9e005ecae652f17daf3736baab63d5ea
+  data.tar.gz: 195eb8e27607f719808954914a409b356c249384cacd0535fab65652b02cd4ec
 SHA512:
-  metadata.gz: c29614452bbbd5b1c52e6fcee20fd2308479e508a03d15d98ddd3ca73c3ad746dff9e9bfffb8979768f456d68ce5bbfaa286d96c2ef62c65e306bd3d0fa15495
-  data.tar.gz: f8a2ac34c8a34a3a7308a49b6e17a57bf71c13718a58838f61e8e5d45699f3d9dee766a3786d4fd11be52601f02e9168803f49a8b4ce35ef7d404bef95523584
+  metadata.gz: 187b1740a3f0e54f061c9b293df233c32993eb00ca4a218e1b32b7888c8b72c4fb9d2889ec7a2a469f95d3b39242b9adc8c02167c76065a5dcfd45262714793c
+  data.tar.gz: 132fecbea3bcf8783a0ad2ca540747af4a74e882d0fdba60bf0491c0ee19e52e9ef378d6a39ab3df89cbac3bcd6dee760959f969f45e17587b6a0b643f9e1bb3

data/lib/brick/config.rb

@@ -234,7 +234,7 @@ module Brick
 
     # Polymorphic associations
     def polymorphics
-      @mutex.synchronize { @polymorphics }
+      @mutex.synchronize { @polymorphics ||= {} }
     end
 
     def polymorphics=(polys)
@@ -344,7 +344,7 @@ module Brick
     end
 
     def table_name_prefixes
-      @mutex.synchronize { @table_name_prefixes }
+      @mutex.synchronize { @table_name_prefixes ||= {} }
     end
 
     def table_name_prefixes=(value)
@@ -384,7 +384,7 @@ module Brick
     end
 
     def metadata_columns
-      @mutex.synchronize { @metadata_columns }
+      @mutex.synchronize { @metadata_columns ||= ['created_at', 'updated_at', 'deleted_at'] }
     end
 
     def metadata_columns=(columns)

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?
@@ -1174,34 +1175,6 @@ Might want to add this in your brick.rb:
   end
 end
 
-if ::Brick.enable_routes? && Object.const_defined?('ActionDispatch')
-  require 'brick/route_mapper'
-  ActionDispatch::Routing::RouteSet.class_exec do
-    # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
-    prepend ::Brick::RouteSet
-  end
-  ActionDispatch::Routing::Mapper.class_exec do
-    include ::Brick::RouteMapper
-  end
-
-  # Do the root route before the Rails Welcome one would otherwise take precedence
-  if (route = ::Brick.config.default_route_fallback).present?
-    action = "#{route}#{'#index' unless route.index('#')}"
-    if ::Brick.config.path_prefix
-      ::Rails.application.routes.append do
-        send(:namespace, ::Brick.config.path_prefix) do
-          send(:root, action)
-        end
-      end
-    elsif ::Rails.application.routes.named_routes.send(:routes)[:root].nil?
-      ::Rails.application.routes.append do
-        send(:root, action)
-      end
-    end
-    ::Brick.established_drf = "/#{::Brick.config.path_prefix}#{action[action.index('#')..-1]}"
-  end
-end
-
 if Object.const_defined?('ActionView')
   require 'brick/frameworks/rails/form_tags'
   require 'brick/frameworks/rails/form_builder'
@@ -1551,7 +1524,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 +1558,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 +1611,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 +1635,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"
@@ -1799,6 +1772,18 @@ class Object
             new_model_class.send(:has_many, hmt_name.to_sym, **options)
           end
         end
+
+        # Auto-support Ransack if it's present
+        if self.respond_to?(:ransackable_attributes)
+          def self.ransackable_attributes(auth_object = nil)
+            column_names + _ransackers.keys
+          end
+
+          def self.ransackable_associations(auth_object = nil)
+            reflect_on_all_associations.map { |a| a.name.to_s } + _ransackers.keys
+          end
+        end
+
         code << "end # model #{full_name}\n"
       end # model class definition
       [built_model, code]
@@ -2618,9 +2603,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 +2993,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/frameworks/rails/engine.rb

@@ -209,51 +209,95 @@ function linkSchemas() {
       # paths['app/models'] << 'lib/brick/frameworks/active_record/models'
       config.brick = ActiveSupport::OrderedOptions.new
       ActiveSupport.on_load(:before_initialize) do |app|
-        if ::Rails.application.respond_to?(:reloader)
-          ::Rails.application.reloader.to_prepare { Module.class_exec &::Brick::ADD_CONST_MISSING }
-        else # For Rails < 5.0, just load it once at the start
-          Module.class_exec &::Brick::ADD_CONST_MISSING
+
+        # --------------------------------------------
+        # 1. Load three initializers early
+        #    (inflectsions.rb, brick.rb, apartment.rb)
+        # Very first thing, load inflections since we'll be using .pluralize and .singularize on table and model names
+        if File.exist?(inflections = ::Rails.root&.join('config/initializers/inflections.rb') || '')
+          load inflections
         end
         require 'brick/join_array'
-        is_development = (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
-        ::Brick.enable_models = app.config.brick.fetch(:enable_models, true)
-        ::Brick.enable_controllers = app.config.brick.fetch(:enable_controllers, is_development)
-        ::Brick.enable_views = app.config.brick.fetch(:enable_views, is_development)
-        ::Brick.enable_routes = app.config.brick.fetch(:enable_routes, is_development)
-        ::Brick.skip_database_views = app.config.brick.fetch(:skip_database_views, false)
-
-        # Specific database tables and views to omit when auto-creating models
-        ::Brick.exclude_tables = app.config.brick.fetch(:exclude_tables, [])
-
-        # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
-        ::Brick.config.table_name_prefixes ||= app.config.brick.fetch(:table_name_prefixes, {})
-
-        # Columns to treat as being metadata for purposes of identifying associative tables for has_many :through
-        ::Brick.metadata_columns = app.config.brick.fetch(:metadata_columns, ['created_at', 'updated_at', 'deleted_at'])
-
-        # Columns for which to add a validate presence: true even though the database doesn't have them marked as NOT NULL
-        ::Brick.not_nullables = app.config.brick.fetch(:not_nullables, [])
-
-        # Additional references (virtual foreign keys)
-        ::Brick.additional_references = app.config.brick.fetch(:additional_references, nil)
-
-        # Custom columns to add to a table, minimally defined with a name and DSL string
-        ::Brick.custom_columns = app.config.brick.fetch(:custom_columns, nil)
-
-        # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
-        ::Brick.order = app.config.brick.fetch(:order, {})
+        # Now the Brick initializer since there may be important schema things configured
+        if !::Brick.initializer_loaded && File.exist?(brick_initializer = ::Rails.root&.join('config/initializers/brick.rb') || '')
+          ::Brick.initializer_loaded = load brick_initializer
+
+          # After loading the initializer, add compatibility for ActiveStorage and ActionText if those haven't already been
+          # defined.  (Further JSON configuration for ActiveStorage metadata happens later in the after_initialize hook.)
+          # begin
+            ['ActiveStorage', 'ActionText'].each do |ar_extension|
+              if Object.const_defined?(ar_extension) &&
+                 (extension = Object.const_get(ar_extension)).respond_to?(:table_name_prefix) &&
+                 !::Brick.config.table_name_prefixes.key?(as_tnp = extension.table_name_prefix)
+                ::Brick.config.table_name_prefixes[as_tnp] = ar_extension
+              end
+            end
+          # rescue # NoMethodError
+          # end
 
-        # Skip creating a has_many association for these
-        ::Brick.exclude_hms = app.config.brick.fetch(:exclude_hms, nil)
+          # Support the followability gem:  https://github.com/nejdetkadir/followability
+          if Object.const_defined?('Followability') && !::Brick.config.table_name_prefixes.key?('followability_')
+            ::Brick.config.table_name_prefixes['followability_'] = 'Followability'
+          end
+        end
+        # Load the initializer for the Apartment gem a little early so that if .excluded_models and
+        # .default_schema are specified then we can work with non-tenanted models more appropriately
+        if (apartment = Object.const_defined?('Apartment')) &&
+           File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
+          require 'apartment/adapters/abstract_adapter'
+          Apartment::Adapters::AbstractAdapter.class_exec do
+            if instance_methods.include?(:process_excluded_models)
+              def process_excluded_models
+                # All other models will share a connection (at Apartment.connection_class) and we can modify at will
+                Apartment.excluded_models.each do |excluded_model|
+                  begin
+                    process_excluded_model(excluded_model)
+                  rescue NameError => e
+                    (@bad_models ||= []) << excluded_model
+                  end
+                end
+              end
+            end
+          end
+          unless @_apartment_loaded
+            load apartment_initializer
+            @_apartment_loaded = true
+          end
+        end
 
-        # Has one relationships
-        ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
+        if ::Brick.enable_routes? && Object.const_defined?('ActionDispatch')
+          require 'brick/route_mapper'
+          ActionDispatch::Routing::RouteSet.class_exec do
+            # In order to defer auto-creation of any routes that already exist, calculate Brick routes only after having loaded all others
+            prepend ::Brick::RouteSet
+          end
+          ActionDispatch::Routing::Mapper.class_exec do
+            include ::Brick::RouteMapper
+          end
 
-        # accepts_nested_attributes_for relationships
-        ::Brick.nested_attributes = app.config.brick.fetch(:nested_attributes, nil)
+          # Do the root route before the Rails Welcome one would otherwise take precedence
+          if (route = ::Brick.config.default_route_fallback).present?
+            action = "#{route}#{'#index' unless route.index('#')}"
+            if ::Brick.config.path_prefix
+              ::Rails.application.routes.append do
+                send(:namespace, ::Brick.config.path_prefix) do
+                  send(:root, action)
+                end
+              end
+            elsif ::Rails.application.routes.named_routes.send(:routes)[:root].nil?
+              ::Rails.application.routes.append do
+                send(:root, action)
+              end
+            end
+            ::Brick.established_drf = "/#{::Brick.config.path_prefix}#{action[action.index('#')..-1]}"
+          end
+        end
 
-        # Polymorphic associations
-        ::Brick.polymorphics = app.config.brick.fetch(:polymorphics, nil)
+        if ::Rails.application.respond_to?(:reloader)
+          ::Rails.application.reloader.to_prepare { Module.class_exec &::Brick::ADD_CONST_MISSING }
+        else # For Rails < 5.0, just load it once at the start
+          Module.class_exec &::Brick::ADD_CONST_MISSING
+        end
       end
 
       # After we're initialized and before running the rest of stuff, put our configuration in place
@@ -497,20 +541,43 @@ window.addEventListener(\"popstate\", linkSchemas);
               end
             end
           end
-          ::ActiveAdmin::Views::TitleBar.class_exec do
-            alias _brick_build_title_tag build_title_tag
-            def build_title_tag
-              if klass = begin
-                           aa_id = helpers.instance_variable_get(:@current_tab)&.id
-                           ::Brick.relations.fetch(aa_id, nil)&.fetch(:class_name, nil)&.constantize
-                         rescue
-                         end
-                h2((@title + link_to_brick(nil,
-                  BRICK_SVG.html_safe, # This would do well to be sized a bit smaller
-                  { title: "#{@_name} in Brick" }
-                )).html_safe)
-              else
-                _brick_build_title_tag # Revert to the original
+          if (aav = ::ActiveAdmin::Views).const_defined?('TitleBar') # ActiveAdmin < 4.0
+            aav::TitleBar.class_exec do
+              alias _brick_build_title_tag build_title_tag
+              def build_title_tag
+                if klass = begin
+                             aa_id = helpers.instance_variable_get(:@current_tab)&.id
+                             ::Brick.relations.fetch(aa_id, nil)&.fetch(:class_name, nil)&.constantize
+                           rescue
+                           end
+                  h2((@title + link_to_brick(nil,
+                    BRICK_SVG.html_safe, # This would do well to be sized a bit smaller
+                    { title: "#{@_name} in Brick" }
+                  )).html_safe)
+                else
+                  _brick_build_title_tag # Revert to the original
+                end
+              end
+            end
+          else # ActiveAdmin 4.0 or later
+            is_aa_4x = true
+            ::ActiveAdmin::ResourceController.class_exec do
+              include ActionView::Helpers::UrlHelper
+              include ::Brick::Rails::FormTags
+              alias _brick_default_page_title default_page_title
+              def default_page_title
+                dpt = _brick_default_page_title
+                if klass = begin
+                             ::Brick.relations.fetch(@current_menu_item&.id, nil)&.fetch(:class_name, nil)&.constantize
+                           rescue
+                           end
+                  (dpt + link_to_brick(nil,
+                    BRICK_SVG.html_safe,
+                    { title: "#{dpt} in Brick" }
+                  )).html_safe
+                else
+                  dpt
+                end
               end
             end
           end
@@ -523,9 +590,8 @@ window.addEventListener(\"popstate\", linkSchemas);
                 div class: "blank_slate_container", id: "dashboard_default_message" do
                   span class: "blank_slate" do
                     span I18n.t("active_admin.dashboard_welcome.welcome")
-                    small I18n.t("active_admin.dashboard_welcome.call_to_action")
                   end
-                end
+                end unless is_aa_4x
               end
             end
           end
@@ -1402,7 +1468,7 @@ end %>#{"
   end
   \"<tr><td colspan=\\\"#\{td_count}\\\">Children: #\{child_links.join(' ')}</tr>\".html_safe
 end
-%><%= if (page_num = @#{res_name = table_name.pluralize}._brick_page_num)
+%><%= if (page_num = @#{res_name = table_name.pluralize}&._brick_page_num)
            \"<tr><td colspan=\\\"#\{td_count}\\\">Page #\{page_num}</td></tr>\".html_safe
          end %></table>#{template_link}<%
    if description.present? %><span class=\"__brick\"><%=
@@ -1790,11 +1856,12 @@ flatpickr(\".timepicker\", {enableTime: true, noCalendar: true});
 <link rel=\"stylesheet\" type=\"text/css\" href=\"https://cdn.jsdelivr.net/npm/trix@2.0/dist/trix.min.css\">
 <% end %>
 
-<% # Started with v0.14.4 of vanilla-jsoneditor
+<% # Good up until v0.19.0, and then with v0.20.0 of vanilla-jsoneditor started to get:
+   # Uncaught TypeError: Failed to resolve module specifier \"immutable-json-patch\". Relative references must start with either \"/\", \"./\", or \"../\".
    if @_json_fields_present %>
-<link rel=\"stylesheet\" type=\"text/css\" href=\"https://cdn.jsdelivr.net/npm/vanilla-jsoneditor/themes/jse-theme-default.min.css\">
+<link rel=\"stylesheet\" type=\"text/css\" href=\"https://cdn.jsdelivr.net/npm/vanilla-jsoneditor@0.19.0/themes/jse-theme-default.min.css\">
 <script type=\"module\">
-  import { JSONEditor } from \"https://cdn.jsdelivr.net/npm/vanilla-jsoneditor/index.min.js\";
+  import { JSONEditor } from \"https://cdn.jsdelivr.net/npm/vanilla-jsoneditor@0.19.0/index.min.js\";
   document.querySelectorAll(\"input.jsonpicker\").forEach(function (inp) {
     var jsonDiv;
     if (jsonDiv = document.getElementById(\"_br_json_\" + inp.id)) {

data/lib/brick/frameworks/rails/form_tags.rb

@@ -69,8 +69,8 @@ module Brick::Rails::FormTags
 
       if show_aa_button != false && Object.const_defined?('ActiveAdmin')
         ActiveAdmin.application.namespaces.names.each do |ns|
-        out << "
-          <td>#{link_to_brick(
+          out << "
+        <td>#{link_to_brick(
             ::Brick::Rails::AA_PNG.html_safe,
             { index_proc: Proc.new do |aa_model, relation|
                             path_helper = "#{ns}_#{relation.fetch(:auto_prefixed_schema, nil)}#{aa_model.model_name.route_key}_path".to_sym

data/lib/brick/reflect_tables.rb

@@ -31,61 +31,8 @@ module Brick
 
       orig_schema = nil
       if (relations = ::Brick.relations).keys == [:db_name]
-        ::Brick.remove_instance_variable(:@_additional_references_loaded) if ::Brick.instance_variable_defined?(:@_additional_references_loaded)
+        # ::Brick.remove_instance_variable(:@_additional_references_loaded) if ::Brick.instance_variable_defined?(:@_additional_references_loaded)
 
-        # --------------------------------------------
-        # 1. Load three initializers early
-        #    (inflectsions.rb, brick.rb, apartment.rb)
-        # Very first thing, load inflections since we'll be using .pluralize and .singularize on table and model names
-        if File.exist?(inflections = ::Rails.root&.join('config/initializers/inflections.rb') || '')
-          load inflections
-        end
-        # Now the Brick initializer since there may be important schema things configured
-        if !::Brick.initializer_loaded && File.exist?(brick_initializer = ::Rails.root&.join('config/initializers/brick.rb') || '')
-          ::Brick.initializer_loaded = load brick_initializer
-
-          # After loading the initializer, add compatibility for ActiveStorage and ActionText if those haven't already been
-          # defined.  (Further JSON configuration for ActiveStorage metadata happens later in the after_initialize hook.)
-          # begin
-            ['ActiveStorage', 'ActionText'].each do |ar_extension|
-              if Object.const_defined?(ar_extension) &&
-                 (extension = Object.const_get(ar_extension)).respond_to?(:table_name_prefix) &&
-                 !::Brick.config.table_name_prefixes.key?(as_tnp = extension.table_name_prefix)
-                ::Brick.config.table_name_prefixes[as_tnp] = ar_extension
-              end
-            end
-          # rescue # NoMethodError
-          # end
-
-          # Support the followability gem:  https://github.com/nejdetkadir/followability
-          if Object.const_defined?('Followability') && !::Brick.config.table_name_prefixes.key?('followability_')
-            ::Brick.config.table_name_prefixes['followability_'] = 'Followability'
-          end
-        end
-        # Load the initializer for the Apartment gem a little early so that if .excluded_models and
-        # .default_schema are specified then we can work with non-tenanted models more appropriately
-        if (apartment = Object.const_defined?('Apartment')) &&
-           File.exist?(apartment_initializer = ::Rails.root.join('config/initializers/apartment.rb'))
-          require 'apartment/adapters/abstract_adapter'
-          Apartment::Adapters::AbstractAdapter.class_exec do
-            if instance_methods.include?(:process_excluded_models)
-              def process_excluded_models
-                # All other models will share a connection (at Apartment.connection_class) and we can modify at will
-                Apartment.excluded_models.each do |excluded_model|
-                  begin
-                    process_excluded_model(excluded_model)
-                  rescue NameError => e
-                    (@bad_models ||= []) << excluded_model
-                  end
-                end
-              end
-            end
-          end
-          unless @_apartment_loaded
-            load apartment_initializer
-            @_apartment_loaded = true
-          end
-        end
         # Only for Postgres  (Doesn't work in sqlite3 or MySQL)
         # puts ActiveRecord::Base.execute_sql("SELECT current_setting('SEARCH_PATH')").to_a.inspect
 
@@ -438,7 +385,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
         loop do
           klass = Object
           proposed_name_parts.each do |part|
-            if klass.const_defined?(part)
+            if klass.const_defined?(part) && klass.name != part
               begin
                 klass = klass.const_get(part)
               rescue NoMethodError => e

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -232,10 +232,6 @@ module Brick
                 )
               )
             )
-        # unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
-        #        (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
-        #          (!a.belongs_to? || (same_type = (fk_type = model_cols[a.foreign_key.to_s]&.type) == pk_type))
-        #        )
           if same_type == false # We really do want to test specifically for false here, and not nil!
             puts "WARNING:
   Foreign key column #{a.klass.table_name}.#{a.foreign_key} is #{fk_type}, but the primary key it relates to, #{primary_klass.table_name}.#{a_pk}, is #{pk_type}.

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/install_generator.rb

@@ -171,7 +171,7 @@ if ActiveRecord::Base.respond_to?(:brick_select) && !::Brick.initializer_loaded
 
   # # Custom path prefix to apply to all auto-generated Brick routes.  Also causes auto-generated controllers
   # # to be created inside a module with the same name.
-  # ::Brick.path_prefix = 'admin'
+  # ::Brick.path_prefix = 'brick'
 
   # # Normally all are enabled in development mode, and for security reasons only models are enabled in production
   # # and test.  This allows you to either (a) turn off models entirely, or (b) enable controllers, views, and routes

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.205
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-07 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -285,7 +285,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Create a Rails app from data alone