brick 1.0.14 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09600b354a3f70f8680f3dd7a9be9349e6666c013c09a7c9a0dc240e811344ee'
-  data.tar.gz: 0f6ec90f3d38338797a10ec4fc338fae6fdea5b9fddb376c2044fe719afaaa8b
+  metadata.gz: 2dbd4fef7ab5c2796e75a0bce86316be00ebceb02aa5a0b8053f75b27d433c57
+  data.tar.gz: daa2802b2fec6533ccfed8fa9178129c6633f92b83fb092fefa48a657cb36e9b
 SHA512:
-  metadata.gz: 7189638a98c3899d49473a48638dce78da4ed109ed1d4a69185015f9b19428d658fa40ef0f70aa1652a478754b6c1b683a963424ec3e627c56e97b3c2528bba7
-  data.tar.gz: a843f0ec11b7e40bc4cf0a7387ab33e87edd4d9a36de1e24d10c899d969e148015da346fe7b7915f9ffd5a769818e8948de36beb1a368d38a6bb3ab3a97ca7c5
+  metadata.gz: 33f97461748561fb21900ccb1b4b39c13803e68e04fea807851b467587907577a10bd5b5a2470cde5f50bca019d3cc986b512545bf700477028f68751bb95e6a
+  data.tar.gz: 97605afbe32e2509800f510ca2984651cc196c048a6267fa31d65363815bc6f4484955aacd45fae1553fe70453f1bee283766812a2f92678bc35e516ec594738

data/lib/brick/config.rb

@@ -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
@@ -177,13 +183,16 @@ module ActiveSupport::Dependencies
     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)
+      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
@@ -246,15 +255,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 +275,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 +332,12 @@ 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
+                      # binding.pry if assoc[:fk] == 'issue_severity_id'
+                      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 +372,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)
@@ -401,6 +417,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 +520,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 +559,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
@@ -638,16 +663,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 +684,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 +697,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])
@@ -685,15 +721,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)
 
@@ -285,24 +291,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 = 14
+    TINY = 15
 
     # 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)
@@ -269,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 for auto-generated models to 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,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.15
 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