brick 1.0.13 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c22e9b6dcc1ca819d7cdc6852def21d10e5c5c23f6fc7489b1fe5ae52b6c68e
-  data.tar.gz: 2242f7c0045e294fc505a479054a43d7d4355a0f7b6bf8407122f6f426eea541
+  metadata.gz: 30eeeb5fb81003f790234885589b29f227b7f4f2d498accb07da5cd8ea425084
+  data.tar.gz: 1841386c2750c2aef744a7ee555b649e2fc0298367684d261faf64297b8430c0
 SHA512:
-  metadata.gz: 6b42dcae433ac8c0fbc91dbf9952451548af6e72eadb466f98c8c6d084be7217df192aa6fc141a18d1e76bd25a551746cf155799045d66f88f41ede99b36b39e
-  data.tar.gz: 7ab155441e2868af3fe0b2a5339ec6614c18ff9d641a076f678ef6baa7b943cad88c97443db3c70506206c54f2b754a1892490d977f3e714fb66c889fe107fa5
+  metadata.gz: 64c5747800aaa5469f2ff2b0be3ae5056fa383c6d246e7aff15b19eb4a588e15e72f5d1ecb384879b3b7f175cab28961fb4984e11d5994085b215f442d722389
+  data.tar.gz: ec3418092244d97b3006086aaf0484ee1ab4342cf2c16716239f7127c8e23056dc25e1714e51523bdb8f87fb6b88c322dabefb096fe7bf0b1f695568b636d4b8

data/lib/brick/config.rb

@@ -91,6 +91,14 @@ module Brick
       @mutex.synchronize { @model_descrips = descrips }
     end
 
+    def sti_namespace_prefixes
+      @mutex.synchronize { @sti_namespace_prefixes ||= {} }
+    end
+
+    def sti_namespace_prefixes=(prefixes)
+      @mutex.synchronize { @sti_namespace_prefixes = prefixes }
+    end
+
     def skip_database_views
       @mutex.synchronize { @skip_database_views }
     end
@@ -107,6 +115,14 @@ module Brick
       @mutex.synchronize { @exclude_tables = value }
     end
 
+    def models_inherit_from
+      @mutex.synchronize { @models_inherit_from }
+    end
+
+    def models_inherit_from=(value)
+      @mutex.synchronize { @models_inherit_from = value }
+    end
+
     def table_name_prefixes
       @mutex.synchronize { @table_name_prefixes }
     end
@@ -122,5 +138,13 @@ module Brick
     def metadata_columns=(columns)
       @mutex.synchronize { @metadata_columns = columns }
     end
+
+    def not_nullables
+      @mutex.synchronize { @not_nullables }
+    end
+
+    def not_nullables=(columns)
+      @mutex.synchronize { @not_nullables = columns }
+    end
   end
 end

data/lib/brick/extensions.rb

@@ -136,38 +136,78 @@ module ActiveRecord
 
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
-        ::Brick.sti_models[type_name] = { base: self } unless type_name.blank?
-        module_prefixes = type_name.split('::')
-        module_prefixes.unshift('') unless module_prefixes.first.blank?
-        candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
-        if File.exists?(candidate_file)
-          # Find this STI class normally
+        if ::Brick.sti_models.key?(type_name)
+          # puts ['X', self.name, type_name].inspect
           _brick_find_sti_class(type_name)
         else
-          # Build missing prefix modules if they don't yet exist
-          this_module = Object
-          module_prefixes[1..-2].each do |module_name|
-            mod = if this_module.const_defined?(module_name)
-                    this_module.const_get(module_name)
-                  else
-                    this_module.const_set(module_name.to_sym, Module.new)
-                  end
+          # This auto-STI is more of a brute-force approach, building modules where needed
+          # The more graceful alternative is the overload of ActiveSupport::Dependencies#autoload_module! found below
+          ::Brick.sti_models[type_name] = { base: self } unless type_name.blank?
+          module_prefixes = type_name.split('::')
+          module_prefixes.unshift('') unless module_prefixes.first.blank?
+          module_name = module_prefixes[0..-2].join('::')
+          if ::Brick.config.sti_namespace_prefixes&.key?("::#{module_name}::") ||
+             ::Brick.config.sti_namespace_prefixes&.key?("#{module_name}::")
+            _brick_find_sti_class(type_name)
+          elsif File.exists?(candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb'))
+            _brick_find_sti_class(type_name) # Find this STI class normally
+          else
+            # Build missing prefix modules if they don't yet exist
+            this_module = Object
+            module_prefixes[1..-2].each do |module_name|
+              this_module = if this_module.const_defined?(module_name)
+                              this_module.const_get(module_name)
+                            else
+                              this_module.const_set(module_name.to_sym, Module.new)
+                            end
+            end
+            if this_module.const_defined?(class_name = module_prefixes.last.to_sym)
+              this_module.const_get(class_name)
+            else
+              # Build STI subclass and place it into the namespace module
+              # %%% Does this ever get used???
+              puts [this_module.const_set(class_name, klass = Class.new(self)).name, class_name].inspect
+              klass
+            end
           end
-          # Build missing prefix modules if they don't yet exist
-          this_module.const_set(module_prefixes.last.to_sym, klass = Class.new(self))
+        end
+      end
+    end
+  end
+end
+
+if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works with previous non-zeitwerk auto-loading
+  module ActiveSupport::Dependencies
+    class << self
+      # %%% Probably a little more targeted than other approaches we've taken thusfar
+      # This happens before the whole parent check
+      alias _brick_autoload_module! autoload_module!
+      def autoload_module!(*args)
+        into, const_name, qualified_name, path_suffix = args
+        if (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{into.name}::", nil)&.constantize)
+          ::Brick.sti_models[qualified_name] = { base: base_class }
+          # Build subclass and place it into the specially STI-namespaced module
+          into.const_set(const_name.to_sym, klass = Class.new(base_class))
+          # %%% used to also have:  autoload_once_paths.include?(base_path) || 
+          autoloaded_constants << qualified_name unless autoloaded_constants.include?(qualified_name)
           klass
+        elsif (base_class = ::Brick.config.sti_namespace_prefixes&.fetch("::#{const_name}", nil)&.constantize)
+          # Build subclass and place it into Object
+          Object.const_set(const_name.to_sym, klass = Class.new(base_class))
+        else
+          _brick_autoload_module!(*args)
         end
       end
     end
   end
 end
 
-# Object.class_exec do
 class Object
   class << self
     alias _brick_const_missing const_missing
     def const_missing(*args)
-      return Object.const_get(args.first) if Object.const_defined?(args.first)
+      return self.const_get(args.first) if self.const_defined?(args.first)
+      return Object.const_get(args.first) if Object.const_defined?(args.first) unless self == Object
 
       class_name = args.first.to_s
       # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
@@ -175,43 +215,57 @@ class Object
       # that is, checking #qualified_name_for with:  from_mod, const_name
       # If we want to support namespacing in the future, might have to utilise something like this:
       # path_suffix = ActiveSupport::Dependencies.qualified_name_for(Object, args.first).underscore
-      # return Object._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
+      # return self._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(path_suffix)
       # If the file really exists, go and snag it:
-      return Object._brick_const_missing(*args) if ActiveSupport::Dependencies.search_for_file(class_name.underscore)
+      if !(is_found = ActiveSupport::Dependencies.search_for_file(class_name.underscore)) && (filepath = self.name&.split('::'))
+        filepath = (filepath[0..-2] + [class_name]).join('/').underscore + '.rb'
+      end
+      if is_found
+        return self._brick_const_missing(*args)
+      elsif ActiveSupport::Dependencies.search_for_file(filepath) # Last-ditch effort to pick this thing up before we fill in the gaps on our own
+        my_const = parent.const_missing(class_name) # ends up having:  MyModule::MyClass
+        return my_const
+      end
 
       relations = ::Brick.instance_variable_get(:@relations)[ActiveRecord::Base.connection_pool.object_id] || {}
       is_controllers_enabled = ::Brick.enable_controllers? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
       result = if is_controllers_enabled && class_name.end_with?('Controller') && (plural_class_name = class_name[0..-11]).length.positive?
-        # Otherwise now it's up to us to fill in the gaps
-        if (model = ActiveSupport::Inflector.singularize(plural_class_name).constantize)
-          # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
-          build_controller(class_name, plural_class_name, model, relations)
-        end
-      elsif ::Brick.enable_models?
-        # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
-        # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
-        plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
-        singular_table_name = ActiveSupport::Inflector.underscore(model_name)
-
-        # Adjust for STI if we know of a base model for the requested model name
-        table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
-                       base_model.table_name
-                     else
-                       ActiveSupport::Inflector.pluralize(singular_table_name)
-                     end
-
-        # Maybe, just maybe there's a database table that will satisfy this need
-        if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
-          build_model(model_name, singular_table_name, table_name, relations, matching)
-        end
-      end
+                 # Otherwise now it's up to us to fill in the gaps
+                 if (model = ActiveSupport::Inflector.singularize(plural_class_name).constantize)
+                   # if it's a controller and no match or a model doesn't really use the same table name, eager load all models and try to find a model class of the right name.
+                   build_controller(class_name, plural_class_name, model, relations)
+                 end
+               elsif ::Brick.enable_models?
+                 # See if a file is there in the same way that ActiveSupport::Dependencies#load_missing_constant
+                 # checks for it in ~/.rvm/gems/ruby-2.7.5/gems/activesupport-5.2.6.2/lib/active_support/dependencies.rb
+                 plural_class_name = ActiveSupport::Inflector.pluralize(model_name = class_name)
+                 singular_table_name = ActiveSupport::Inflector.underscore(model_name)
+ 
+                 # Adjust for STI if we know of a base model for the requested model name
+                 table_name = if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
+                               base_model.table_name
+                             else
+                               ActiveSupport::Inflector.pluralize(singular_table_name)
+                             end
+ 
+                 # Maybe, just maybe there's a database table that will satisfy this need
+                 if (matching = [table_name, singular_table_name, plural_class_name, model_name].find { |m| relations.key?(m) })
+                   build_model(model_name, singular_table_name, table_name, relations, matching)
+                 end
+               end
       if result
         built_class, code = result
         puts "\n#{code}"
         built_class
+      elsif ::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}")
+#         module_prefixes = type_name.split('::')
+#         path = self.name.split('::')[0..-2] + []
+#         module_prefixes.unshift('') unless module_prefixes.first.blank?
+#         candidate_file = Rails.root.join('app/models' + module_prefixes.map(&:underscore).join('/') + '.rb')
+        self._brick_const_missing(*args)
       else
-        puts "MISSING! #{args.inspect} #{table_name}"
-        Object._brick_const_missing(*args)
+        puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
+        self._brick_const_missing(*args)
       end
     end
 
@@ -223,12 +277,15 @@ class Object
 
       # Are they trying to use a pluralised class name such as "Employees" instead of "Employee"?
       if table_name == singular_table_name && !ActiveSupport::Inflector.inflections.uncountable.include?(table_name)
-        raise NameError.new("Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\".")
+        unless ::Brick.config.sti_namespace_prefixes&.key?("::#{singular_table_name.titleize}::")
+          puts "Warning: Class name for a model that references table \"#{matching}\" should be \"#{ActiveSupport::Inflector.singularize(model_name)}\"."
+        end
+        return
       end
       if (base_model = ::Brick.sti_models[model_name]&.fetch(:base, nil))
         is_sti = true
       else
-        base_model = ActiveRecord::Base
+        base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
       end
       code = +"class #{model_name} < #{base_model.name}\n"
       built_model = Class.new(base_model) do |new_model_class|
@@ -277,6 +334,11 @@ class Object
             options = {}
             singular_table_name = ActiveSupport::Inflector.singularize(assoc[:inverse_table])
             macro = if assoc[:is_bt]
+                      # Try to take care of screwy names if this is a belongs_to going to an STI subclass
+                      if (primary_class = assoc.fetch(:primary_class, nil)) &&
+                         (sti_inverse_assoc = primary_class.reflect_on_all_associations.find { |a| a.macro == :has_many && a.options[:class_name] == self.name && assoc[:fk] = a.foreign_key })
+                        assoc_name = sti_inverse_assoc.options[:inverse_of].to_s || assoc_name
+                      end
                       need_class_name = singular_table_name.underscore != assoc_name
                       need_fk = "#{assoc_name}_id" != assoc[:fk]
                       if (inverse = assoc[:inverse])
@@ -311,7 +373,7 @@ class Object
                     end
             # Figure out if we need to specially call out the class_name and/or foreign key
             # (and if either of those then definitely also a specific inverse_of)
-            options[:class_name] = singular_table_name.camelize if need_class_name
+            options[:class_name] = assoc[:primary_class]&.name || singular_table_name.camelize if need_class_name
             # Work around a bug in CPK where self-referencing belongs_to associations double up their foreign keys
             if need_fk # Funky foreign key?
               options[:foreign_key] = if assoc[:fk].is_a?(Array)
@@ -342,12 +404,13 @@ class Object
             fks.each do |fk|
               source = nil
               this_hmt_fk = if fks.length > 1
-                              singular_assoc_name = ActiveSupport::Inflector.singularize(fk.first[:inverse][:assoc_name])
+                              singular_assoc_name = fk.first[:inverse][:assoc_name].singularize
                               source = fk.last
-                              through = ActiveSupport::Inflector.pluralize(fk.first[:alternate_name])
+                              through = fk.first[:alternate_name].pluralize
                               "#{singular_assoc_name}_#{hmt_fk}"
                             else
-                              through = fk.first[:assoc_name]
+                              source = fk.last unless hmt_fk.singularize == fk.last
+                              through = fk.first[:assoc_name].pluralize
                               hmt_fk
                             end
               code << "  has_many :#{this_hmt_fk}, through: #{(assoc_name = through.to_sym).to_sym.inspect}#{", source: :#{source}" if source}\n"
@@ -356,6 +419,14 @@ class Object
               self.send(:has_many, this_hmt_fk.to_sym, **options)
             end
           end
+          # Not NULLables
+          relation[:cols].each do |col, datatype|
+            if (datatype[3] && ar_pks.exclude?(col) && ::Brick.config.metadata_columns.exclude?(col)) ||
+               ::Brick.config.not_nullables.include?("#{matching}.#{col}")
+              code << "  validates :#{col}, presence: true\n"
+              self.send(:validates, col.to_sym, { presence: true })
+            end
+          end
         end
         code << "end # model #{model_name}\n\n"
       end # class definition
@@ -451,7 +522,8 @@ module ActiveRecord::ConnectionHandling
         "SELECT t.table_name AS relation_name, t.table_type,
           c.column_name, c.data_type,
           COALESCE(c.character_maximum_length, c.numeric_precision) AS max_length,
-          tc.constraint_type AS const, kcu.constraint_name AS \"key\"
+          tc.constraint_type AS const, kcu.constraint_name AS \"key\",
+          c.is_nullable
         FROM INFORMATION_SCHEMA.tables AS t
           LEFT OUTER JOIN INFORMATION_SCHEMA.columns AS c ON t.table_schema = c.table_schema
             AND t.table_name = c.table_name
@@ -489,7 +561,7 @@ module ActiveRecord::ConnectionHandling
                 end
           key << col_name if key
           cols = relation[:cols] # relation.fetch(:cols) { relation[:cols] = [] }
-          cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name)]
+          cols[col_name] = [r['data_type'], r['max_length'], measures&.include?(col_name), r['is_nullable'] == 'NO']
           # puts "KEY! #{r['relation_name']}.#{col_name} #{r['key']} #{r['const']}" if r['key']
         end
       else # MySQL2 acts a little differently, bringing back an array for each row
@@ -593,16 +665,17 @@ module Brick
       bt_assoc_name = bt_assoc_name[0..-4] if bt_assoc_name.end_with?('_id')
 
       bts = (relation = relations.fetch(fk[0], nil))&.fetch(:fks) { relation[:fks] = {} }
-      hms = (relation = relations.fetch(fk[2], nil))&.fetch(:fks) { relation[:fks] = {} }
+      primary_table = (is_class = fk[2].is_a?(Hash) && fk[2].key?(:class)) ? (primary_class = fk[2][:class].constantize).table_name : fk[2]
+      hms = (relation = relations.fetch(primary_table, nil))&.fetch(:fks) { relation[:fks] = {} } unless is_class
 
       unless (cnstr_name = fk[3])
         # For any appended references (those that come from config), arrive upon a definitely unique constraint name
-        cnstr_base = cnstr_name = "(brick) #{fk[0]}_#{fk[2]}"
+        cnstr_base = cnstr_name = "(brick) #{fk[0]}_#{is_class ? fk[2][:class].underscore : fk[2]}"
         cnstr_added_num = 1
         cnstr_name = "#{cnstr_base}_#{cnstr_added_num += 1}" while bts&.key?(cnstr_name) || hms&.key?(cnstr_name)
         missing = []
         missing << fk[0] unless relations.key?(fk[0])
-        missing << fk[2] unless relations.key?(fk[2])
+        missing << primary_table unless is_class || relations.key?(primary_table)
         unless missing.empty?
           tables = relations.reject { |k, v| v.fetch(:isView, nil) }.keys.sort
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent #{'table'.pluralize(missing.length)} #{missing.join(' and ')}. (Available tables include #{tables.join(', ')}.)"
@@ -613,8 +686,12 @@ module Brick
           puts "Brick: Additional reference #{fk.inspect} refers to non-existent column #{fk[1]}. (Columns present in #{fk[0]} are #{columns.join(', ')}.)"
           return
         end
-        if (redundant = bts.find { |k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == fk[2] })
-          puts "Brick: Additional reference #{fk.inspect} is redundant and can be removed.  (Already established by #{redundant.first}.)"
+        if (redundant = bts.find { |k, v| v[:inverse]&.fetch(:inverse_table, nil) == fk[0] && v[:fk] == fk[1] && v[:inverse_table] == primary_table })
+          if is_class && !redundant.last.key?(:class)
+            redundant.last[:primary_class] = primary_class # Round out this BT so it can find the proper :source for a HMT association that references an STI subclass
+          else
+            puts "Brick: Additional reference #{fk.inspect} is redundant and can be removed.  (Already established by #{redundant.first}.)"
+          end
           return
         end
       end
@@ -622,10 +699,16 @@ module Brick
         assoc_bt[:fk] = assoc_bt[:fk].is_a?(String) ? [assoc_bt[:fk], fk[1]] : assoc_bt[:fk].concat(fk[1])
         assoc_bt[:assoc_name] = "#{assoc_bt[:assoc_name]}_#{fk[1]}"
       else
-        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: fk[2] }
+        assoc_bt = bts[cnstr_name] = { is_bt: true, fk: fk[1], assoc_name: bt_assoc_name, inverse_table: primary_table }
+      end
+      if is_class
+        # For use in finding the proper :source for a HMT association that references an STI subclass
+        assoc_bt[:primary_class] = primary_class
+        # For use in finding the proper :inverse_of for a BT association that references an STI subclass
+        # assoc_bt[:inverse_of] = primary_class.reflect_on_all_associations.find { |a| a.foreign_key == bt[1] }
       end
 
-      unless ::Brick.config.skip_hms&.any? { |skip| fk[0] == skip[0] && fk[1] == skip[1] && fk[2] == skip[2] }
+      unless is_class || ::Brick.config.skip_hms&.any? { |skip| fk[0] == skip[0] && fk[1] == skip[1] && primary_table == skip[2] }
         cnstr_name = "hm_#{cnstr_name}"
         if (assoc_hm = hms.fetch(cnstr_name, nil))
           assoc_hm[:fk] = assoc_hm[:fk].is_a?(String) ? [assoc_hm[:fk], fk[1]] : assoc_hm[:fk].concat(fk[1])
@@ -640,15 +723,5 @@ module Brick
       end
       # hms[cnstr_name] << { is_bt: false, fk: fk[1], assoc_name: fk[0], alternate_name: bt_assoc_name, inverse_table: fk[0] }
     end
-
-    # Rails < 4.0 doesn't have ActiveRecord::RecordNotUnique, so use the more generic ActiveRecord::ActiveRecordError instead
-    ar_not_unique_error = ActiveRecord.const_defined?('RecordNotUnique') ? ActiveRecord::RecordNotUnique : ActiveRecord::ActiveRecordError
-    class NoUniqueColumnError < ar_not_unique_error
-    end
-
-    # Rails < 4.2 doesn't have ActiveRecord::RecordInvalid, so use the more generic ActiveRecord::ActiveRecordError instead
-    ar_invalid_error = ActiveRecord.const_defined?('RecordInvalid') ? ActiveRecord::RecordInvalid : ActiveRecord::ActiveRecordError
-    class LessThanHalfAreMatchingColumnsError < ar_invalid_error
-    end
   end
 end

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

@@ -16,12 +16,18 @@ module Brick
         # Specific database tables and views to omit when auto-creating models
         ::Brick.exclude_tables = app.config.brick.fetch(:exclude_tables, [])
 
+        # Class for auto-generated models to inherit from
+        ::Brick.models_inherit_from = app.config.brick.fetch(:models_inherit_from, ActiveRecord::Base)
+
         # When table names have specific prefixes, automatically place them in their own module with a table_name_prefix.
         ::Brick.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)
 
@@ -84,7 +90,6 @@ module Brick
 
                 schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
                 hms_columns = +'' # Used for 'index'
-                # puts skip_hms.inspect
                 hms_headers = hms.each_with_object([]) do |hm, s|
                   next if skip_hms.key?(hm.last.name)
 
@@ -264,7 +269,7 @@ function changeout(href, param, value) {
     <% if (collection = @#{obj_name}.first.#{hm_name}).empty? %>
       <tr><td>(none)</td></tr>
     <% else %>
-      <% collection.order(#{pk.inspect}).uniq.each do |#{hm_singular_name = hm_name.singularize}| %>
+      <% collection.order(#{pk.inspect}).uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
         <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm_singular_name}_path(#{hm_singular_name}.#{pk})) %></td></tr>
       <% end %>
     <% end %>
@@ -285,24 +290,8 @@ function changeout(href, param, value) {
 
         if ::Brick.enable_routes? || (ENV['RAILS_ENV'] || ENV['RACK_ENV'])  == 'development'
           ActionDispatch::Routing::RouteSet.class_exec do
-            alias _brick_finalize_routeset! finalize!
-            def finalize!(*args, **options)
-              unless @finalized
-                existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
-                ::Rails.application.routes.append do
-                  # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
-                  # If auto-controllers and auto-models are both enabled then this makes sense:
-                  ::Brick.relations.each do |k, v|
-                    unless existing_controllers.key?(controller_name = k.underscore.pluralize)
-                      options = {}
-                      options[:only] = [:index, :show] if v.key?(:isView)
-                      send(:resources, controller_name.to_sym, **options)
-                    end
-                  end
-                end
-              end
-              _brick_finalize_routeset!(*args, **options)
-            end
+            # 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
         end
 

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -174,6 +174,11 @@ module Brick
       Brick.config.exclude_tables = value
     end
 
+    # @api public
+    def models_inherit_from=(value)
+      Brick.config.models_inherit_from = value
+    end
+
     # @api public
     def table_name_prefixes=(value)
       Brick.config.table_name_prefixes = value
@@ -184,6 +189,11 @@ module Brick
       Brick.config.metadata_columns = value
     end
 
+    # @api public
+    def not_nullables=(value)
+      Brick.config.not_nullables = value
+    end
+
     # Additional table associations to use (Think of these as virtual foreign keys perhaps)
     # @api public
     def additional_references=(ars)
@@ -228,6 +238,13 @@ module Brick
       Brick.config.model_descrips = descrips
     end
 
+    # Module prefixes to build out and associate with specific base STI models
+    # @api public
+    def sti_namespace_prefixes=(snp)
+      Brick.config.sti_namespace_prefixes = snp
+    end
+
+
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.
     #
@@ -262,6 +279,25 @@ module Brick
       VERSION::STRING
     end
   end
+
+  module RouteSet
+    def finalize!
+      existing_controllers = routes.each_with_object({}) { |r, s| c = r.defaults[:controller]; s[c] = nil if c }
+      ::Rails.application.routes.append do
+        # %%% TODO: If no auto-controllers then enumerate the controllers folder in order to build matching routes
+        # If auto-controllers and auto-models are both enabled then this makes sense:
+        ::Brick.relations.each do |k, v|
+          unless existing_controllers.key?(controller_name = k.underscore.pluralize)
+            options = {}
+            options[:only] = [:index, :show] if v.key?(:isView)
+            send(:resources, controller_name.to_sym, **options)
+          end
+        end
+      end
+      super
+    end
+  end
+
 end
 
 require 'brick/version_number'

data/lib/generators/brick/install_generator.rb

@@ -94,6 +94,9 @@ module Brick
 # # Any tables or views you'd like to skip when auto-creating models
 # Brick.exclude_tables = ['custom_metadata', 'version_info']
 
+# # Class that auto-generated models should inherit from
+# Brick.models_inherit_from = ApplicationRecord
+
 # # When table names have specific prefixes automatically place them in their own module with a table_name_prefix.
 # Brick.table_name_prefixes = { 'nav_' => 'Navigation' }
 
@@ -128,6 +131,10 @@ module Brick
 # # database:
 # Brick.metadata_columns = ['last_update']
 
+# # Columns for which to add a validate presence: true even though the database doesn't have them marked as NOT NULL.
+# # Designated by <table name>.<column name>
+# Brick.not_nullables = ['users.name']
+
 # # A simple DSL is available to allow more user-friendly display of objects.  Normally a user object might be shown
 # # as its first non-metadata column, or if that is not available then something like \"User #45\" where 45 is that
 # # object's ID.  If there is no primary key then even that is not possible, so the object's .to_s method is called.
@@ -135,6 +142,16 @@ module Brick
 # # user, then you can use model_descrips like this, putting expressions with property references in square brackets:
 # Brick.model_descrips = { 'User' => '[profile.firstname] [profile.lastname]' }
 
+# # Specify STI subclasses either directly by name or as a general module prefix that should always relate to a specific
+# # parent STI class.  The prefixed :: here for these examples is mandatory.  Also having a suffixed :: means instead of
+# # a class reference, this is for a general namespace reference.  So in this case requests for, say, either of the
+# # non-existant classes Animals::Cat or Animals::Goat (or anything else with the module prefix of \"Animals::\" would
+# # build a model that inherits from Animal.  And a request specifically for the class Snake would build a new model
+# # that inherits from Reptile, and no other request would do this -- only specifically for Snake.  The ending ::
+# # indicates that it's a module prefix instead of a specific class name.
+# Brick.sti_namespace_prefixes = { '::Animals::' => 'Animal',
+#                                  '::Snake' => 'Reptile' }
+
 # # If a default route is not supplied, Brick attempts to find the most \"central\" table and wires up the default
 # # route to go to the :index action for what would be a controller for that table.  You can specify any controller
 # # name and action you wish in order to override this and have that be the default route when none other has been

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.16
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord