brick 1.0.14 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09600b354a3f70f8680f3dd7a9be9349e6666c013c09a7c9a0dc240e811344ee'
-  data.tar.gz: 0f6ec90f3d38338797a10ec4fc338fae6fdea5b9fddb376c2044fe719afaaa8b
+  metadata.gz: 7f1a45a5262526e69cf49f16773049eb348e3971bddf09ecf05927002a265019
+  data.tar.gz: e9566a423a19ab55d44522b44e8b4abfcc39e92335b6093fe782c6344644bbbe
 SHA512:
-  metadata.gz: 7189638a98c3899d49473a48638dce78da4ed109ed1d4a69185015f9b19428d658fa40ef0f70aa1652a478754b6c1b683a963424ec3e627c56e97b3c2528bba7
-  data.tar.gz: a843f0ec11b7e40bc4cf0a7387ab33e87edd4d9a36de1e24d10c899d969e148015da346fe7b7915f9ffd5a769818e8948de36beb1a368d38a6bb3ab3a97ca7c5
+  metadata.gz: cb89dff96dccc7051bc854fe523b03f818255d81e4f2e2a65eb9808115e719b8bad98e38114f15ee79b32b1f035c95c364a74392948cd2e99f4030e6988e0217
+  data.tar.gz: cd5507fde2f1f23481696ab051d14f89e5e7e7d3fc2be97af947ff287313b7ada8ca7b4e3f9e0e54dc2ab7f14e7f39a3c18f78cf7fc995c58b3d60cf68487973

data/lib/brick/config.rb

@@ -66,12 +66,12 @@ module Brick
     end
 
     # Skip creating a has_many association for these
-    def skip_hms
-      @mutex.synchronize { @skip_hms }
+    def exclude_hms
+      @mutex.synchronize { @exclude_hms }
     end
 
-    def skip_hms=(skips)
-      @mutex.synchronize { @skip_hms = skips }
+    def exclude_hms=(skips)
+      @mutex.synchronize { @exclude_hms = skips }
     end
 
     # Associations to treat as a has_one
@@ -115,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
@@ -130,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

@@ -137,6 +137,7 @@ module ActiveRecord
       alias _brick_find_sti_class find_sti_class
       def find_sti_class(type_name)
         if ::Brick.sti_models.key?(type_name)
+          # puts ['X', self.name, type_name].inspect
           _brick_find_sti_class(type_name)
         else
           # This auto-STI is more of a brute-force approach, building modules where needed
@@ -145,8 +146,8 @@ module ActiveRecord
           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[2..-1]) # Take off the leading '::' and see if this matches
+          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
@@ -154,15 +155,20 @@ module ActiveRecord
             # 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_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
-            # Build STI subclass and place it into the namespace module
-            this_module.const_set(module_prefixes.last.to_sym, klass = Class.new(self))
-            klass
           end
         end
       end
@@ -170,22 +176,27 @@ module ActiveRecord
   end
 end
 
-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
-      else
-        _brick_autoload_module!(*args)
+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
@@ -246,15 +257,14 @@ class Object
         built_class, code = result
         puts "\n#{code}"
         built_class
-      elsif ::Brick.config.sti_namespace_prefixes&.key?(class_name)
-        # binding.pry
+      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}"
+        puts "MISSING! #{self.name} #{args.inspect} #{table_name}"
         self._brick_const_missing(*args)
       end
     end
@@ -267,13 +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)
-        puts "Warning: 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|
@@ -322,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])
@@ -356,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)
@@ -387,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"
@@ -401,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
@@ -496,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
@@ -534,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
@@ -602,7 +629,11 @@ module ActiveRecord::ConnectionHandling
       puts "\nClasses that can be built from views:"
       views.keys.each { |k| puts ActiveSupport::Inflector.singularize(k).camelize }
     end
-    # pp relations; nil
+    # Try to load the initializer pretty danged early
+    if File.exist?(brick_initialiser = Rails.root.join('config/initializers/brick.rb'))
+      load brick_initialiser
+      ::Brick.load_additional_references
+    end
 
     # relations.keys.each { |k| ActiveSupport::Inflector.singularize(k).camelize.constantize }
     # Layout table describes permissioned hierarchy throughout
@@ -638,16 +669,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(', ')}.)"
@@ -658,8 +690,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
@@ -667,10 +703,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.exclude_hms&.any? { |exclusion| fk[0] == exclusion[0] && fk[1] == exclusion[1] && primary_table == exclusion[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])
@@ -685,15 +727,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,17 +16,23 @@ 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)
 
         # Skip creating a has_many association for these
-        ::Brick.skip_hms = app.config.brick.fetch(:skip_hms, nil)
+        ::Brick.exclude_hms = app.config.brick.fetch(:exclude_hms, nil)
 
         # Has one relationships
         ::Brick.has_ones = app.config.brick.fetch(:has_ones, nil)
@@ -70,34 +76,34 @@ module Brick
                 bts, hms = ::Brick.get_bts_and_hms(@_brick_model)
                 # Mark has_manys that go to an associative ("join") table so that they are skipped in the UI,
                 # as well as any possible polymorphic associations
-                skip_hms = {}
+                exclude_hms = {}
                 associatives = hms.each_with_object({}) do |hmt, s|
                   if (through = hmt.last.options[:through])
-                    skip_hms[through] = nil
+                    exclude_hms[through] = nil
                     s[hmt.first] = hms[through] # End up with a hash of HMT names pointing to join-table associations
                   elsif hmt.last.inverse_of.nil?
                     puts "SKIPPING #{hmt.last.name.inspect}"
                     # %%% If we don't do this then below associative.name will find that associative is nil
-                    skip_hms[hmt.last.name] = nil
+                    exclude_hms[hmt.last.name] = nil
                   end
                 end
 
                 schema_options = ::Brick.db_schemas.each_with_object(+'') { |v, s| s << "<option value=\"#{v}\">#{v}</option>" }.html_safe
+                table_options = ::Brick.relations.keys.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)
+                  next if exclude_hms.key?((hm_assoc = hm.last).name)
 
                   if args.first == 'index'
-                    hm_fk_name = if hm.last.options[:through]
-                                   associative = associatives[hm.last.name]
+                    hm_fk_name = if hm_assoc.options[:through]
+                                   associative = associatives[hm_assoc.name]
                                    "'#{associative.name}.#{associative.foreign_key}'"
                                  else
-                                   hm.last.foreign_key
+                                   hm_assoc.foreign_key
                                  end
-                    hms_columns << if hm.last.macro == :has_many
+                    hms_columns << if hm_assoc.macro == :has_many
 "<td>
-  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm.last.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
+  <%= link_to \"#\{#{obj_name}.#{hm.first}.count\} #{hm.first}\", #{hm_assoc.klass.name.underscore.pluralize}_path({ #{hm_fk_name}: #{obj_name}.#{pk} }) unless #{obj_name}.#{hm.first}.count.zero? %>
 </td>\n"
                                    else # has_one
 "<td>
@@ -105,7 +111,7 @@ module Brick
 </td>\n"
                                    end
                   end
-                  s << [hm.last, "H#{hm.last.macro == :has_one ? 'O' : 'M'}#{'T' if hm.last.options[:through]} #{hm.first}"]
+                  s << [hm_assoc, "H#{hm_assoc.macro == :has_one ? 'O' : 'M'}#{'T' if hm_assoc.options[:through]} #{hm.first}"]
                 end
 
                 css = "<style>
@@ -150,10 +156,20 @@ table tbody tr.active-row {
 }
 
 a.show-arrow {
+  font-size: 1.5em;
+  text-decoration: none;
+}
+a.big-arrow {
   font-size: 2.5em;
   text-decoration: none;
 }
-</style>"
+</style>
+<% def is_bcrypt?(val)
+  val.is_a?(String) && val.length == 60 && val.start_with?('$2a$')
+end
+def hide_bcrypt(val)
+  is_bcrypt?(val) ? '(hidden)' : val
+end %>"
 
                 script = "<script>
 var schemaSelect = document.getElementById(\"schema\");
@@ -168,8 +184,28 @@ if (schemaSelect) {
     location.href = changeout(location.href, \"_brick_schema\", this.value);
   });
 }
+
+var tblSelect = document.getElementById(\"tbl\");
+if (tblSelect) {
+  tblSelect.value = changeout(location.href);
+  tblSelect.addEventListener(\"change\", function () {
+    var lhr = changeout(location.href, null, this.value);
+    if (brickSchema)
+      lhr = changeout(lhr, \"_brick_schema\", schemaSelect.value);
+    location.href = lhr;
+  });
+}
+
 function changeout(href, param, value) {
   var hrefParts = href.split(\"?\");
+  if (param === undefined || param === null) {
+    hrefParts = hrefParts[0].split(\"://\");
+    var pathParts = hrefParts[hrefParts.length - 1].split(\"/\");
+    if (value === undefined)
+      return pathParts[1];
+    else
+      return hrefParts[0] + \"://\" + pathParts[0] + \"/\" + value;
+  }
   var params = hrefParts.length > 1 ? hrefParts[1].split(\"&\") : [];
   params = params.reduce(function (s, v) { var parts = v.split(\"=\"); s[parts[0]] = parts[1]; return s; }, {});
   if (value === undefined) return params[param];
@@ -183,6 +219,7 @@ function changeout(href, param, value) {
 "#{css}
 <p style=\"color: green\"><%= notice %></p>#{"
 <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+<select id=\"tbl\">#{table_options}</select>
 <h1>#{model_name.pluralize}</h1>
 <% if @_brick_params&.present? %><h3>where <%= @_brick_params.each_with_object([]) { |v, s| s << \"#\{v.first\} = #\{v.last.inspect\}\" }.join(', ') %></h3><% end %>
 <table id=\"#{table_name}\">
@@ -204,7 +241,7 @@ function changeout(href, param, value) {
   <tbody>
   <% @#{table_name}.each do |#{obj_name}| %>
   <tr>#{"
-    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'show-arrow' } %></td>" if pk }
+    <td><%= link_to '⇛', #{obj_name}_path(#{obj_name}.#{pk}), { class: 'big-arrow' } %></td>" if pk }
     <% #{obj_name}.attributes.each do |k, val| %>
       <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
       <td>
@@ -213,9 +250,9 @@ function changeout(href, param, value) {
         # send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))
         # Otherwise we get stuff like:
         # ActionView::Template::Error (undefined method `vehicle_path' for #<ActionView::Base:0x0000000033a888>) %>
-        <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
+        <%= bt_obj = bt[1].find_by(bt[2] => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
       <% else %>
-        <%= val %>
+        <%= hide_bcrypt(val) %>
       <% end %>
       </td>
     <% end %>
@@ -232,40 +269,51 @@ function changeout(href, param, value) {
   "#{css}
     <p style=\"color: green\"><%= notice %></p>#{"
     <select id=\"schema\">#{schema_options}</select>" if ::Brick.db_schemas.length > 1}
+    <select id=\"tbl\">#{table_options}</select>
     <h1>#{model_name}: <%= (obj = @#{obj_name}.first).brick_descrip %></h1>
     <%= link_to '(See all #{obj_name.pluralize})', #{table_name}_path %>
+  <%= form_for obj do |f| %>
   <table>
   <% bts = { #{bts.each_with_object([]) { |v, s| s << "#{v.first.inspect} => [#{v.last.first.inspect}, #{v.last[1].name}, #{v.last[1].primary_key.inspect}]"}.join(', ')} }
       @#{obj_name}.first.attributes.each do |k, val| %>
     <tr>
     <% next if k == '#{pk}' || ::Brick.config.metadata_columns.include?(k) %>
     <th class=\"show-field\">
-    <% if (bt = bts[k]) %>
+    <% if (bt = bts[k])
+      # Add a final member in this array with descriptive options to be used in <select> drop-downs
+      # %%% Only do this if the user has permissions to edit this bt field
+      bt << bt[1].order(:#{pk}).map { |obj| [obj.brick_descrip, obj.#{pk}] } if bt.length < 4 %>
       BT <%= \"#\{bt.first\}-\" unless bt[1].name.underscore == bt.first.to_s %><%= bt[1].name %>
     <% else %>
       <%= k %>
     <% end %>
     </th>
     <td>
-    <% if (bt = bts[k]) %>
-      <%= bt_obj = bt[1].find_by(bt.last => val); link_to(bt_obj.brick_descrip, send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym))) if bt_obj %>
+    <% if (bt = bts[k]) # bt_obj.brick_descrip %>
+      <%= f.select k.to_sym, bt[3], {}, prompt: 'Select #{model_name}' %>
+      <%= bt_obj = bt[1].find_by(bt[2] => val); link_to('⇛', send(\"#\{bt_obj_class = bt[1].name.underscore\}_path\".to_sym, bt_obj.send(bt[1].primary_key.to_sym)), { class: 'show-arrow' }) if bt_obj %>
+    <% elsif is_bcrypt?(val) %>
+      <%= hide_bcrypt(val) %>
     <% else %>
-      <%= val %>
+      <%= f.text_field k.to_sym %>
     <% end %>
     </td>
     </tr>
   <% end %>
   </table>
+  <% end %>
 
   #{hms_headers.map do |hm|
     next unless (pk = hm.first.klass.primary_key)
   "<table id=\"#{hm_name = hm.first.name.to_s}\">
     <tr><th>#{hm.last}</th></tr>
-    <% if (collection = @#{obj_name}.first.#{hm_name}).empty? %>
+    <% collection = @#{obj_name}.first.#{hm_name}
+    collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection]
+    if collection.empty? %>
       <tr><td>(none)</td></tr>
     <% else %>
-      <% collection.order(#{pk.inspect}).uniq.each do |#{hm_singular_name = hm_name.singularize}| %>
-        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm_singular_name}_path(#{hm_singular_name}.#{pk})) %></td></tr>
+      <% collection.uniq.each do |#{hm_singular_name = hm_name.singularize.underscore}| %>
+        <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass.name.underscore}_path(#{hm_singular_name}.#{pk})) %></td></tr>
       <% end %>
     <% end %>
   </table>" end.join}
@@ -285,33 +333,14 @@ 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
 
-        # Additional references (virtual foreign keys)
-        if (ars = ::Brick.config.additional_references)
-          ars.each do |fk|
-            ::Brick._add_bt_and_hm(fk[0..2])
-          end
-        end
+        # Just in case it hadn't been done previously when we tried to load the brick initialiser,
+        # go make sure we've loaded additional references (virtual foreign keys).
+        ::Brick.load_additional_references
 
         # Find associative tables that can be set up for has_many :through
         ::Brick.relations.each do |_key, tbl|

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 14
+    TINY = 17
 
     # 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)
@@ -198,12 +208,12 @@ module Brick
     # Skip creating a has_many association for these
     # (Uses the same exact three-part format as would define an additional_reference)
     # @api public
-    def skip_hms=(skips)
+    def exclude_hms=(skips)
       if skips
         skips = skips.call if skips.is_a?(Proc)
         skips = skips.to_a unless skips.is_a?(Array)
         skips = [skips] unless skips.empty? || skips.first.is_a?(Array)
-        Brick.config.skip_hms = skips
+        Brick.config.exclude_hms = skips
       end
     end
 
@@ -234,6 +244,18 @@ module Brick
       Brick.config.sti_namespace_prefixes = snp
     end
 
+    # Load additional references (virtual foreign keys)
+    # This is attempted early if a brick initialiser file is found, and then again as a failsafe at the end of our engine's initialisation
+    # %%% Maybe look for differences the second time 'round and just add new stuff instead of entirely deferring
+    def load_additional_references
+      return if @_additional_references_loaded
+
+      if (ars = ::Brick.config.additional_references)
+        ars.each { |fk| ::Brick._add_bt_and_hm(fk[0..2]) }
+        @_additional_references_loaded = true
+      end
+    end
+
 
     # Returns Brick's `::Gem::Version`, convenient for comparisons. This is
     # recommended over `::Brick::VERSION::STRING`.
@@ -269,6 +291,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' }
 
@@ -111,7 +114,7 @@ module Brick
 # # Skip creating a has_many association for these
 # # (Uses the same exact three-part format as would define an additional_reference)
 # # Say for instance that we didn't care to display the favourite colours that users have:
-# Brick.skip_hms = [['users', 'favourite_colour_id', 'colours']]
+# Brick.exclude_hms = [['users', 'favourite_colour_id', 'colours']]
 
 # # By default primary tables involved in a foreign key relationship will indicate a \"has_many\" relationship pointing
 # # back to the foreign table.  In order to represent a \"has_one\" association instead, an override can be provided
@@ -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,10 +142,15 @@ 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]' }
 
-# # Module prefixes to be built out and associated when new subclasses are requested for specific base STI models
-# # (If this setting exists then only these subclasses will be honoured, and other requested )
-# # The prefixed :: here on the sample module name LetterTemplates is optional.  Used here for clarity.
-# Brick.sti_namespace_prefixes = { '::LetterTemplates' => 'LetterTemplate' }
+# # 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

metadata

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