brick 1.0.130 → 1.0.131

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 902948e0d502bc9c1b604f3e99b975ab8c7d42c378888280d84dac6aef2aa7d0
-  data.tar.gz: 82988754dcae3ccc67eb5997531b3fa218ecf364f076ecf221fac201412baff0
+  metadata.gz: 6e9356edd43a6af6120f30bfbcd520383f3ae700e6ff04be11ebdd3493852ef4
+  data.tar.gz: a099075c53acc9bf29c718043cc619b5ab4f895366f9c7ddd14d53c8f7f432b8
 SHA512:
-  metadata.gz: 780184ebc02c020389bc2239e115e885df056fa6895ed32bd35b5315f2e55f86deb679f2966e7290118bc54f4d50478b4240d7d77470d27a5902af22948d83f1
-  data.tar.gz: 39c37a9db2c7c392209491e1609f8ab4c2b64d27371452b60310d326bd462b5e653196697d0faf8f4bf801793400e073bf73f2ed72a38e9c66bd9b8e98d1e778
+  metadata.gz: 9f9df598bad9ce128a88f4fe364d568be8c38eee57e595024866d39a255b42f513a26adc68d64d14cdecd4b5d13fb7424935f17df7dbb41c3bda2ae31057a4c7
+  data.tar.gz: 845e5747a916a338ee494426e4ef0ac6fd5c65c3579df0210c8a80468887fac12103407acfbaee3659b3b45763f98ef0bd109935d70920b932b4fd41cc15fdc5

data/lib/brick/extensions.rb

@@ -670,6 +670,7 @@ module ActiveRecord
                          link_back = []
                          # Track polymorphic type field if necessary
                          if hm.source_reflection.options[:as]
+                           # Might be able to simplify as:  hm.source_reflection.type
                            poly_ft = [hm.source_reflection.inverse_of.foreign_type, hmt_assoc.source_reflection.class_name]
                          end
                          # link_back << hm.source_reflection.inverse_of.name
@@ -753,7 +754,8 @@ module ActiveRecord
 
         pri_tbl = hm.active_record
         pri_key = hm.options[:primary_key] || pri_tbl.primary_key
-        unless hm.klass.column_names.include?(pri_key)
+        unless hm.active_record.column_names.include?(pri_key)
+          # %%% When this gets hit then if an attempt is made to display the ERD, it might end up being blank
           nix << k
           next
         end
@@ -874,6 +876,12 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
     def brick_list
       pks = klass.primary_key.is_a?(String) ? [klass.primary_key] : klass.primary_key
       selects = pks.each_with_object([]) { |pk, s| s << pk unless s.include?(pk) }
+      # Get foreign keys for anything marked to be auto-preloaded, or a self-referencing JOIN
+      klass_cols = klass.column_names
+      reflect_on_all_associations.each do |a|
+        selects << a.foreign_key if a.belongs_to? && (preload_values.include?(a.name) ||
+                                    (!a.options[:polymorphic] && a.klass == klass && klass_cols.include?(a.foreign_key)))
+      end
       # ActiveStorage compatibility
       selects << 'service_name' if klass.name == 'ActiveStorage::Blob' && ActiveStorage::Blob.columns_hash.key?('service_name')
       selects << 'blob_id' if klass.name == 'ActiveStorage::Attachment' && ActiveStorage::Attachment.columns_hash.key?('blob_id')
@@ -1013,16 +1021,17 @@ Module.class_exec do
     is_controller = requested.end_with?('Controller')
     # self.name is nil when a model name is requested in an .erb file
     if self.name && ::Brick.config.path_prefix
-      camelize_prefix = ::Brick.config.path_prefix.camelize
+      split_self_name.shift if (split_self_name = self.name.split('::')).first.blank?
       # Asking for the prefix module?
+      camelize_prefix = ::Brick.config.path_prefix.camelize
       if self == Object && requested == camelize_prefix
         Object.const_set(args.first, (built_module = Module.new))
         puts "module #{camelize_prefix}; end\n"
         return built_module
-      end
-      split_self_name.shift if (split_self_name = self.name.split('::')).first.blank?
-      if split_self_name.first == camelize_prefix
+      elsif module_parent == Object && self.name == camelize_prefix ||
+            module_parent.name == camelize_prefix && module_parent.module_parent == Object
         split_self_name.shift # Remove the identified path prefix from the split name
+        is_brick_prefix = true
         if is_controller
           brick_root = split_self_name.empty? ? self : camelize_prefix.constantize
         end
@@ -1055,26 +1064,30 @@ Module.class_exec do
                     self
                   end
     # puts "#{self.name} - #{args.first}"
-    desired_classname = (self == Object || !name) ? requested : "#{name}::#{requested}"
-    if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) &&
-        # Reset `possible` if it's a controller request that's not a perfect match
-        # Was:  (possible = nil)  but changed to #local_variable_set in order to suppress the "= should be ==" warning
-        (possible&.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
-       # Try to require the respective Ruby file
-       ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
-                    (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
-        ) && (require_dependency(filename) || true) &&
-        ((possible = self.const_get(args.first)) && possible.name == desired_classname)
-       ) ||
-       # If any class has turned up so far (and we're not in the middle of eager loading)
-       # then return what we've found.
-       (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
-      if ((!brick_root && (filename || possible.instance_of?(Class))) ||
-          (possible.instance_of?(Module) && possible&.module_parent == self) ||
-          (possible.instance_of?(Class) && possible == self)) && # Are we simply searching for ourselves?
-         # Skip when what we found as `possible` is not related to the base class of an STI model
-         (!sti_base || possible.is_a?(sti_base))
-        return possible
+    # Unless it's a Brick prefix looking for a TNP that should create a module ...
+    unless (is_tnp_module = (is_brick_prefix && !is_controller && ::Brick.config.table_name_prefixes.values.include?(requested)))
+      # ... first look around for an existing module or class.
+      desired_classname = (self == Object || !name) ? requested : "#{name}::#{requested}"
+      if ((is_defined = self.const_defined?(args.first)) && (possible = self.const_get(args.first)) &&
+          # Reset `possible` if it's a controller request that's not a perfect match
+          # Was:  (possible = nil)  but changed to #local_variable_set in order to suppress the "= should be ==" warning
+          (possible&.name == desired_classname || (is_controller && binding.local_variable_set(:possible, nil)))) ||
+         # Try to require the respective Ruby file
+         ((filename = ActiveSupport::Dependencies.search_for_file(desired_classname.underscore) ||
+                      (self != Object && ActiveSupport::Dependencies.search_for_file((desired_classname = requested).underscore))
+          ) && (require_dependency(filename) || true) &&
+          ((possible = self.const_get(args.first)) && possible.name == desired_classname)
+         ) ||
+         # If any class has turned up so far (and we're not in the middle of eager loading)
+         # then return what we've found.
+         (is_defined && !::Brick.is_eager_loading) # Used to also have:   && possible != self
+        if ((!brick_root && (filename || possible.instance_of?(Class))) ||
+            (possible.instance_of?(Module) && possible&.module_parent == self) ||
+            (possible.instance_of?(Class) && possible == self)) && # Are we simply searching for ourselves?
+           # Skip when what we found as `possible` is not related to the base class of an STI model
+           (!sti_base || possible.is_a?(sti_base))
+          return possible
+        end
       end
     end
     class_name = ::Brick.namify(requested)
@@ -1109,7 +1122,7 @@ Module.class_exec do
                                    (plural_class_name = class_name.pluralize)].find { |s| Brick.db_schemas&.include?(s) }&.camelize ||
                                   (::Brick.config.sti_namespace_prefixes&.key?("::#{class_name}::") && class_name) ||
                                   (::Brick.config.table_name_prefixes.values.include?(class_name) && class_name))
-               return self.const_get(schema_name) if self.const_defined?(schema_name)
+               return self.const_get(schema_name) if !is_tnp_module && self.const_defined?(schema_name)
 
                # Build out a module for the schema if it's namespaced
                # schema_name = schema_name.camelize

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

@@ -225,7 +225,7 @@ function linkSchemas() {
                                       end
 
         # 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, {})
+        ::Brick.config.table_name_prefixes ||= app.config.brick.fetch(:table_name_prefixes, {})
 
         # Columns to treat as being metadata for purposes of identifying associative tables for has_many :through
         ::Brick.metadata_columns = app.config.brick.fetch(:metadata_columns, ['created_at', 'updated_at', 'deleted_at'])
@@ -625,6 +625,7 @@ window.addEventListener(\"popstate\", linkSchemas);
                 if (class_name = (resource_parts = resource_name.split('/')).last&.singularize)
                   resource_parts[-1] = class_name # Make sure the last part, defining the class name, is singular
                   begin
+                    resource_parts.shift if resource_parts.first == ::Brick.config.path_prefix
                     if (model = Object.const_get(resource_parts.map(&:camelize).join('::')))&.is_a?(Class) && (
                          ['index', 'show'].include?(find_args.first) || # Everything has index and show
                          # Only CUD stuff has create / update / destroy
@@ -1669,7 +1670,7 @@ end
         <% if (assoc = @#{obj_name}.class.reflect_on_association(:#{hm_name})).macro == :has_one &&
               assoc.options&.fetch(:through, nil).nil?
              # In order to apply DSL properly, evaluate this HO the other way around as if it were as a BT
-             collection = assoc.klass.where(assoc.foreign_key => @#{obj_name}.#{pk})
+             collection = assoc.klass.where(assoc.foreign_key => #{pk.is_a?(String) ? "@#{obj_name}.#{pk}" : pk.map { |pk_part| "@#{obj_name}.#{pk_part}" }.inspect})
              collection = collection.instance_exec(&assoc.scopes.first) if assoc.scopes.present?
              if assoc.klass.name == 'ActiveStorage::Attachment'
                br_descrip = begin

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -125,6 +125,7 @@ if Gem::Specification.all_names.any? { |g| g.start_with?('rails-') }
 end
 module Brick
   ALL_API_ACTIONS = [:index, :show, :create, :update, :destroy]
+  CURRENCY_SYMBOLS = '$£¢₵€₠ƒ¥₿₩₪₹₫₴₱₲₳₸₺₼₽៛₡₢₣₤₥₦₧₨₭₮₯₰₶₷₻₾'
 
   class << self
     def sti_models
@@ -200,9 +201,20 @@ module Brick
     end
 
     def get_bts_and_hms(model)
+      model_cols = model.columns_hash
+      pk_type = if (mpk = model.primary_key).is_a?(Array)
+                  # Composite keys should really use:  model.primary_key.map { |pk_part| model_cols[pk_part].type }
+                  model_cols[mpk.first].type
+                else
+                  mpk && model_cols[mpk].type
+                end
       bts, hms = model.reflect_on_all_associations.each_with_object([{}, {}]) do |a, s|
+        # %%% The time will come when we will support type checking of composite foreign keys!
+        # binding.pry if a.foreign_key.is_a?(Array)
         next unless a.polymorphic? || (!a.belongs_to? && (through = a.options[:through])) ||
-                    (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name))
+                    (a.klass && ::Brick.config.exclude_tables.exclude?(a.klass.table_name) &&
+                     (!a.belongs_to? || model_cols[a.foreign_key]&.type == pk_type)
+                    )
 
         if a.belongs_to?
           if a.polymorphic?
@@ -239,6 +251,15 @@ module Brick
               puts "WARNING:  HMT relationship :#{a.name} in model #{model.name} has invalid source :#{a.source_reflection_name}."
               next
             end
+          else
+            if !a.options.key?(:as) && a.klass.column_names.exclude?(a.foreign_key)
+              options = ", #{a.options.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(', ')}" if a.options.present?
+              puts "WARNING:  Model #{model.name} has this association:
+            has_many :#{a.name}#{options}
+          which expects column #{a.foreign_key} to exist in table #{a.klass.table_name}.  This column is missing."
+              next
+
+            end
           end
           s.last[a.name] = a
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.130
+  version: 1.0.131
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-13 00:00:00.000000000 Z
+date: 2023-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord