brick 1.0.85 → 1.0.87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b174d2fbdbef5d71921aa28da8fe7f943eb095fc3dd3c95efb7ac752681917e
-  data.tar.gz: daf09d491031d7f30171b85e25f68ceb36e73df5b183b86ab8269474651fb4b6
+  metadata.gz: b178117c13e6d4feb053c27334b558285765a68a8bdc00c0a1d7a0a708ab3e70
+  data.tar.gz: b4b90b2cef91df1797d3a6534d6658914000b01542fe244d7560d31922c2125e
 SHA512:
-  metadata.gz: 697528d1c7445130ab1cae24b76ad154f72e1a770c26f50ab6bf6f40fe98045c775311c32460e4bfca0869567873166733f0b488eb3e67d9f1a11eb271407032
-  data.tar.gz: ba9004f32e27f8104eb3547bec82682011a2f328e6081774e6afd4485ff14ec10cc5992bcf539fbc328131a5bd5dbde5804b18bcf73f26108ab9a1f9f48b49b7
+  metadata.gz: a7866357360543e3af339aced9e7ff8c1dff803f3f92eebb12926b5cefb4da18415003b729ad5aca3b7771a145035963bd1e49d8a46096bb943a161e4b33ca79
+  data.tar.gz: b2978cf99f81c2ad59b04f656c189763d230542e9eb9d9eb7d3a922c609e79354926357320967f7de53a1a6cc4ec55b61811395138e632cb0f1a96993a31e926

data/lib/brick/compatibility.rb

@@ -10,12 +10,27 @@ unless ActiveRecord.respond_to?(:version)
   end
 end
 
-require 'action_view'
-# Older ActionView didn't have #version
-unless ActionView.respond_to?(:version)
-  module ActionView
+# ActiveSupport, ActionPack, and ActionView before 4.0 didn't have #version
+unless ActiveSupport.respond_to?(:version)
+  module ActiveSupport
     def self.version
-      ActionPack.version
+      ::Gem::Version.new(ActiveSupport::VERSION::STRING)
+    end
+  end
+end
+if Object.const_defined?('ActionPack')
+  unless ActionPack.respond_to?(:version)
+    module ActionPack
+      def self.version
+        ::Gem::Version.new(ActionPack::VERSION::STRING)
+      end
+    end
+  end
+  if Object.const_defined?('ActionView') && !ActionView.respond_to?(:version)
+    module ActionView
+      def self.version
+        ActionPack.version
+      end
     end
   end
 end

data/lib/brick/extensions.rb

@@ -211,7 +211,14 @@ module ActiveRecord
                         this_obj = obj
                         bracket_name.split('.').each do |part|
                           obj_name += ".#{part}"
-                          this_obj = caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
+                          this_obj = begin
+                                       caches.fetch(obj_name) { caches[obj_name] = this_obj&.send(part.to_sym) }
+                                     rescue
+                                       clsnm = part.camelize
+                                       if (possible = this_obj.class.reflect_on_all_associations.select { |a| a.class_name == clsnm || a.klass.base_class.name == clsnm }.first)
+                                         caches[obj_name] = this_obj&.send(possible.name)
+                                       end
+                                     end
                           break if this_obj.nil?
                         end
                         if this_obj.is_a?(ActiveRecord::Base) && (obj_descrip = this_obj.class.brick_descrip(this_obj))
@@ -239,7 +246,7 @@ module ActiveRecord
         pk_alias = [pk_alias] unless pk_alias.is_a?(Array)
         id = []
         pk_alias.each do |pk_alias_part|
-          if (pk_part = obj.send(pk_alias_part))
+          if (pk_part = obj.respond_to?(pk_alias_part) ? obj.send(pk_alias_part) : nil)
             id << pk_part
           end
         end
@@ -608,7 +615,11 @@ module ActiveRecord
           # %%% Need to support {user: :profile}
           next unless assoc_name.is_a?(Symbol)
 
-          table_alias = shift_or_first(chains[klass = reflect_on_association(assoc_name)&.klass])
+          table_alias = if (chain = chains[klass = reflect_on_association(assoc_name)&.klass])
+                          shift_or_first(chain)
+                        else
+                          klass.table_name # ActiveRecord < 4.2 can't (yet) use the cool chains thing
+                        end
           _assoc_names[assoc_name] = [table_alias, klass]
         end
       end
@@ -706,7 +717,7 @@ module ActiveRecord
         join_clause = "LEFT OUTER
 JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{count_column
           }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{tbl_alias}"
-        joins!("#{join_clause} ON #{on_clause.join(' AND ')}")
+        self.joins_values |= ["#{join_clause} ON #{on_clause.join(' AND ')}"] # Same as:  joins!(...)
       end
       while (n = nix.pop)
         klass._br_hm_counts.delete(n)
@@ -723,7 +734,11 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
             s["#{tbl_name}.#{v_parts.last}"] = v.last
           end
         end
-        where!(wheres2)
+        if respond_to?(:where!)
+          where!(wheres2)
+        else # AR < 4.0
+          self.where_values << build_where(wheres2)
+        end
       end
       # Must parse the order_by and see if there are any symbols which refer to BT associations
       # or custom columns as they must be expanded to find the corresponding b_r_model__column
@@ -747,9 +762,10 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
             selects << v if is_distinct
           end
         end
-        order!(*final_order_by)
+        self.order_values |= final_order_by # Same as:  order!(*final_order_by)
       end
-      limit!(1000) # Don't want to get too carried away just yet
+      # Don't want to get too carried away just yet
+      self.limit_value = 1000 # Same as:  limit!(1000)
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
@@ -935,8 +951,13 @@ if ActiveSupport::Dependencies.respond_to?(:autoload_module!) # %%% Only works w
           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))
+          begin
+            # Attempt to find an existing implementation for this subclass
+            base_class.module_parent.const_get(const_name)
+          rescue
+            # Build subclass and place it in the same module as its parent
+            base_class.module_parent.const_set(const_name.to_sym, klass = Class.new(base_class))
+          end
         else
           _brick_autoload_module!(*args)
         end
@@ -1509,9 +1530,10 @@ class Object
           ordering = params['_brick_order']&.split(',')&.map(&:to_sym) || Object.send(:default_ordering, table_name, pk)
           order_by, _ = model._brick_calculate_ordering(ordering, true) # Don't do the txt part
 
-          @_brick_params = (ar_relation = model.all).brick_select(params, (selects = []), order_by,
-                                                                  translations = {},
-                                                                  join_array = ::Brick::JoinArray.new)
+          ar_relation = ActiveRecord.version < Gem::Version.new('4') ? model.preload : model.all
+          @_brick_params = ar_relation.brick_select(params, (selects = []), order_by,
+                                                             translations = {},
+                                                             join_array = ::Brick::JoinArray.new)
           # %%% Add custom HM count columns
           # %%% What happens when the PK is composite?
           counts = model._br_hm_counts.each_with_object([]) do |v, s|
@@ -1523,7 +1545,8 @@ class Object
                    "b_r_#{v.first}.c_t_ AS \"b_r_#{v.first}_ct\""
                  end
           end
-          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_relation.dup._select!(*selects, *counts))
+          ar_select = ar_relation.respond_to?(:_select!) ? ar_relation.dup._select!(*selects, *counts) : ar_relation.select(selects + counts)
+          instance_variable_set("@#{table_name.pluralize}".to_sym, ar_select)
           if namespace && (idx = lookup_context.prefixes.index(table_name))
             lookup_context.prefixes[idx] = "#{namespace.name.underscore}/#{lookup_context.prefixes[idx]}"
           end
@@ -1781,6 +1804,8 @@ end.class_exec do
   # This is done separately so that during testing it can be called right after a migration
   # in order to make sure everything is good.
   def _brick_reflect_tables
+    return unless ::Brick.config.mode == :on
+
     # return if ActiveRecord::Base.connection.current_database == 'postgres'
 
     initializer_loaded = false
@@ -1854,8 +1879,9 @@ end.class_exec do
       ::Brick.db_schemas ||= {}
 
       if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
-        if (possible_schema = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
-          if ::Brick.db_schemas.key?(possible_schema)
+        if (possible_schemas = ::Brick.config.schema_behavior&.[](:multitenant)&.[](:schema_to_analyse))
+          possible_schemas = [possible_schemas] unless possible_schemas.is_a?(Array)
+          if (possible_schema = possible_schemas.find { |ps| ::Brick.db_schemas.key?(ps) })
             ::Brick.default_schema = schema = possible_schema
             orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
@@ -1865,7 +1891,7 @@ end.class_exec do
             orig_schema = ActiveRecord::Base.execute_sql('SELECT current_schemas(true)').first['current_schemas'][1..-2].split(',')
             ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?", schema)
           else
-            puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to a schema called \"#{possible_schema}\".  This schema does not exist. ***"
+            puts "*** In the brick.rb initializer the line \"::Brick.schema_behavior = ...\" refers to schema(s) called #{possible_schemas.map { |s| "\"#{s}\"" }.join(', ')}.  No mentioned schema exists. ***"
           end
         end
       end
@@ -2028,6 +2054,7 @@ ORDER BY 1, 2, c.internal_column_id, acc.position"
       end
       ::Brick.is_oracle = true if ActiveRecord::Base.connection.adapter_name == 'OracleEnhanced'
       # ::Brick.default_schema ||= schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+      ::Brick.default_schema ||= 'public' if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
       fk_references&.each do |fk|
         fk = fk.values unless fk.is_a?(Array)
         # Multitenancy makes things a little more general overall, except for non-tenanted tables

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

@@ -103,12 +103,18 @@ module Brick
               unless (model_name = @_brick_model&.name) ||
                      (is_status = ::Brick.config.add_status && args[0..1] == ['status', ['brick_gem']]) ||
                      (is_orphans = ::Brick.config.add_orphans && args[0..1] == ['orphans', ['brick_gem']])
-                if (possible_template = _brick_find_template(*args, **options))
+                if ActionView.version < ::Gem::Version.new('5.0') # %%% Not sure if this should be perhaps 4.2 instead
+                  begin
+                    if (possible_template = _brick_find_template(*args, **options))
+                      return possible_template
+                    end
+                  rescue
+                  end
+                elsif (possible_template = _brick_find_template(*args, **options))
                   return possible_template
-                else
-                  # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
-                  model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name
                 end
+                # Used to also have:  ActionView.version < ::Gem::Version.new('5.0') &&
+                model_name = (args[1].is_a?(Array) ? set_brick_model(args) : nil)&.name
               end
 
               if @_brick_model
@@ -154,7 +160,7 @@ module Brick
                                                  'nil'
                                                else
                                                  # Postgres column names are limited to 63 characters
-                                                 "#{obj_name}.#{"b_r_#{assoc_name}_ct"[0..62]} || 0"
+                                                 "#{obj_name}.#{"b_r_#{assoc_name}_ct"[0..62]}&.to_i || 0"
                                                end
                                      ", #{set_ct}, #{path_keys(hm_assoc, hm_fk_name, obj_name, pk)}"
                                    end
@@ -919,12 +925,19 @@ erDiagram
              %><%= link_to(\"#\{bt_class} ##\{poly_id}\", send(\"#\{base_class_underscored}_path\".to_sym, poly_id)) if poly_id %><%
            else
              # binding.pry if @_brick_bt_descrip[bt.first][bt[1].first.first].nil?
-             bt_txt = (bt_class = bt[1].first.first).brick_descrip(
+             bt_class = bt[1].first.first
+             descrips = @_brick_bt_descrip[bt.first][bt_class]
+             bt_id_col = if descrips.length == 1
+                           [#{obj_name}.class.reflect_on_association(bt.first)&.foreign_key]
+                         else
+                           descrips.last
+                         end
+             bt_txt = bt_class.brick_descrip(
                # 0..62 because Postgres column names are limited to 63 characters
-               #{obj_name}, (descrips = @_brick_bt_descrip[bt.first][bt_class])[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, (bt_id_col = descrips.last)
+               #{obj_name}, descrips[0..-2].map { |id| #{obj_name}.send(id.last[0..62]) }, bt_id_col
              )
              bt_txt ||= \"<span class=\\\"orphan\\\">&lt;&lt; Orphaned ID: #\{val} >></span>\".html_safe if val
-             bt_id = bt_id_col.map { |id_col| #{obj_name}.send(id_col.to_sym) } %>
+             bt_id = bt_id_col&.map { |id_col| #{obj_name}.respond_to?(id_sym = id_col.to_sym) ? #{obj_name}.send(id_sym) : id_col } %>
           <%= bt_id&.first ? link_to(bt_txt, send(\"#\{bt_class.base_class._brick_index(:singular)}_path\".to_sym, bt_id)) : bt_txt %>
         <% end
          elsif (hms_col = hms_cols[col_name])
@@ -1183,7 +1196,7 @@ end
       s << "<table id=\"#{hm_name}\" class=\"shadow\">
         <tr><th>#{hm[3]}</th></tr>
         <% collection = @#{obj_name}.#{hm_name}
-        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : [collection].compact
+        collection = collection.is_a?(ActiveRecord::Associations::CollectionProxy) ? collection.order(#{pk.inspect}) : collection.to_a.compact
         if collection.empty? %>
           <tr><td>(none)</td></tr>
         <% else %>

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -137,7 +137,7 @@ module Brick
 
     def set_db_schema(params = nil)
       schema = (params ? params['_brick_schema'] : ::Brick.default_schema)
-      if schema && ::Brick.db_schemas&.key?(schema)
+      chosen = if schema && ::Brick.db_schemas&.key?(schema)
         ActiveRecord::Base.execute_sql("SET SEARCH_PATH = ?;", schema)
         schema
       elsif ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
@@ -146,6 +146,7 @@ module Brick
         # ::Brick.apartment_multitenant && tbl_parts.first == Apartment.default_schema
         (orig_schema - ['pg_catalog']).first
       end
+      chosen == ::Brick.default_schema ? nil : chosen
     end
 
     # All tables and views (what Postgres calls "relations" including column and foreign key info)
@@ -218,7 +219,7 @@ module Brick
           skip_hms[through] = nil if hms[through] && model.is_brick?
           # End up with a hash of HMT names pointing to join-table associations
           model._br_associatives[hmt.first] = hms[through] # || hms["#{(opt = hmt.last.options)[:through].to_s.singularize}_#{opt[:source].to_s.pluralize}".to_sym]
-        elsif hmt.last.inverse_of.nil?
+        elsif hmt.last.inverse_of.nil? && ActiveRecord.version >= ::Gem::Version.new('4.2')
           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
@@ -540,7 +541,11 @@ In config/initializers/brick.rb appropriate entries would look something like:
       ::Brick.is_eager_loading = true
       if ::ActiveSupport.version < ::Gem::Version.new('6') ||
          ::Rails.configuration.instance_variable_get(:@autoloader) == :classic
-        ::Rails.configuration.eager_load_namespaces.select { |ns| ns < ::Rails::Application }.each(&:eager_load!)
+        if ::ActiveSupport.version < ::Gem::Version.new('4')
+          ::Rails.application.eager_load!
+        else
+          ::Rails.configuration.eager_load_namespaces.select { |ns| ns < ::Rails::Application }.each(&:eager_load!)
+        end
       else
         Zeitwerk::Loader.eager_load_all
       end
@@ -562,7 +567,8 @@ In config/initializers/brick.rb appropriate entries would look something like:
 
   module RouteSet
     def finalize!
-      unless ::Rails.application.routes.named_routes.route_defined?(:brick_status_path)
+      # %%% Was: ::Rails.application.routes.named_routes.route_defined?(:brick_status_path)
+      unless ::Rails.application.routes.named_routes.names.include?(:brick_status)
         path_prefix = ::Brick.config.path_prefix
         existing_controllers = routes.each_with_object({}) do |r, s|
           c = r.defaults[:controller]
@@ -837,13 +843,21 @@ ActiveSupport.on_load(:active_record) do
         end
       end
 
-      # This only gets added for ActiveRecord < 3.2
       module Reflection
+        # This only gets added for ActiveRecord < 3.2
         unless AssociationReflection.instance_methods.include?(:foreign_key)
           class AssociationReflection < MacroReflection
             alias foreign_key association_foreign_key
           end
         end
+        # And this for ActiveRecord < 4.0
+        unless AssociationReflection.instance_methods.include?(:polymorphic?)
+          class AssociationReflection < MacroReflection
+            def polymorphic?
+              options[:polymorphic]
+            end
+          end
+        end
       end
 
       # ActiveRecord 3.1 and 3.2 didn't try to bring in &block for the .extending() convenience thing
@@ -1022,6 +1036,7 @@ ActiveSupport.on_load(:active_record) do
         delegate :left_outer_joins, to: :all
       end
       class Relation
+        alias :model :klass unless respond_to?(:model) # To support AR < 4.2
         unless MULTI_VALUE_METHODS.include?(:left_outer_joins)
           _multi_value_methods = MULTI_VALUE_METHODS + [:left_outer_joins]
           send(:remove_const, :MULTI_VALUE_METHODS)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.85
+  version: 1.0.87
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-26 00:00:00.000000000 Z
+date: 2022-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: fancy_gets
   requirement: !ruby/object:Gem::Requirement