brick 1.0.91 → 1.0.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81eaa518a99452286bdaf1e5ed33b83962ede9f9c6509f0b472fd0fe19a8eceb
-  data.tar.gz: 06f5653ce40eb6ee1568b380cf3063073ac7735add8aab6c5873a343e8018a70
+  metadata.gz: 6bb6854dd2295476ae00996f23e801587869463aa7114d9240c0e97b1cce25b1
+  data.tar.gz: f174948106c6a06be049f8285fb3358813d09b9970ce484554ad3c86bc3cb8fb
 SHA512:
-  metadata.gz: 7e0a678885c927a7a80c8758d265c2ff351f67ea44e8e1b2c128e123df441f4f72a62f775b9785615eeacbdbff99427e9d1590890bdffd06165ae7b2339fe1af
-  data.tar.gz: 7bd3e424225e435bab4517fb14aeaa3ca128041a746aaf413ecdb17a771444c3413f058ff28cc5e303d074fdd7cc7d21ff66f842667c14226d1849e96d4b3a98
+  metadata.gz: 9384ef5db0a03fcc8fda6a3ceafc763a468f88033420d785814d657303027593c7fef64770087975d73d4041f577864c1d934629cb50083fb93d2591f719f136
+  data.tar.gz: e2b3e21982b9a6d132a3d9d05041759e06a3ac3ffbfdf2ea3675ee0140150f2d33b6e60cbeb0033a7f7469bba227f198a6cc6a0ef34c229ba7a1132cd1175b0d

data/lib/brick/compatibility.rb

@@ -11,6 +11,7 @@ unless ActiveRecord.respond_to?(:version)
 end
 
 # ActiveSupport, ActionPack, and ActionView before 4.0 didn't have #version
+require 'active_support' # Needed for Rails 4.x
 unless ActiveSupport.respond_to?(:version)
   module ActiveSupport
     def self.version

data/lib/brick/extensions.rb

@@ -407,7 +407,13 @@ module ActiveRecord
   end
 
   class Relation
-    attr_reader :_brick_chains, :_arel_applied_aliases
+    attr_reader :_arel_applied_aliases
+
+    # Links from ActiveRecord association pathing names over to real
+    # table correlation names built from AREL aliasing
+    def brick_links
+      @brick_links ||= {}
+    end
 
     # CLASS STUFF
     def _recurse_arel(piece, prefix = '')
@@ -448,7 +454,6 @@ module ActiveRecord
             @_arel_applied_aliases << (alias_name = table.right)
             table = table.left
           end
-          (_brick_chains[table._arel_table_type] ||= []) << (alias_name || table.table_alias || table.name)
         end
         # rubocop:enable Style/IdenticalConditionalBranches
       when Arel::Table # Table
@@ -457,12 +462,8 @@ module ActiveRecord
         # Can get the real table name from:  self._recurse_arel(piece.left)
         names << [piece.left._arel_table_type, piece.right.to_s] # This is simply a string; the alias name itself
       when Arel::Nodes::JoinSource # Leaving this until the end because AR < 3.2 doesn't know at all about JoinSource!
-        # Spin up an empty set of Brick alias name chains at the start
-        @_brick_chains = {}
         # The left side is the "FROM" table
         names << (this_name = [piece.left._arel_table_type, (piece.left.table_alias || piece.left.name)])
-        # # Do not currently need the root "FROM" table in our list of chains
-        # (_brick_chains[this_name.first] ||= []) << this_name.last
         # The right side is an array of all JOINs
         piece.right.each { |join| names << _recurse_arel(join) }
       end
@@ -548,7 +549,6 @@ module ActiveRecord
         # Without working from a duplicate, touching the AREL ast tree sets the @arel instance variable, which causes the relation to be immutable.
         (rel_dupe = dup)._arel_alias_names
         core_selects = selects.dup
-        chains = rel_dupe._brick_chains
         id_for_tables = Hash.new { |h, k| h[k] = [] }
         field_tbl_names = Hash.new { |h, k| h[k] = {} }
         used_col_aliases = {} # Used to make sure there is not a name clash
@@ -569,7 +569,7 @@ module ActiveRecord
           key_alias = nil
           cc.first.each do |cc_part|
             dest_klass = cc_part[0..-2].inject(klass) { |kl, cc_part_term| kl.reflect_on_association(cc_part_term).klass }
-            tbl_name = (field_tbl_names[k][cc_part.last] ||= shift_or_first(chains[dest_klass])).split('.').last
+            tbl_name = rel_dupe.brick_links[cc_part[0..-2].map(&:to_s).join('.')]
             # Deal with the conflict if there are two parts in the custom column named the same,
             # "category.name" and "product.name" for instance will end up with aliases of "name"
             # and "product__name".
@@ -606,23 +606,18 @@ module ActiveRecord
 
         klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
-            next if chains[k1].nil?
+            next unless (tbl_name = rel_dupe.brick_links[v.first.to_s]&.split('.')&.last)
 
-            tbl_name = (field_tbl_names[v.first][k1] ||= shift_or_first(chains[k1])).split('.').last
             # If it's Oracle, quote any AREL aliases that had been applied
             tbl_name = "\"#{tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.include?(tbl_name)
             field_tbl_name = nil
-            v1.map { |x| [translations[x[0..-2].map(&:to_s).join('.')], x.last] }.each_with_index do |sel_col, idx|
-              # unless chains[sel_col.first]
-              #   puts 'You might have some bogus DSL in your brick.rb file'
-              #   next
-              # end
-              field_tbl_name = (field_tbl_names[v.first][sel_col.first] ||= shift_or_first(chains[sel_col.first])).split('.').last
+            v1.map { |x| [x[0..-2].map(&:to_s).join('.'), x.last] }.each_with_index do |sel_col, idx|
+              field_tbl_name = rel_dupe.brick_links[sel_col.first].split('.').last
               # If it's Oracle, quote any AREL aliases that had been applied
               field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && rel_dupe._arel_applied_aliases.include?(field_tbl_name)
 
               # Postgres can not use DISTINCT with any columns that are XML, so for any of those just convert to text
-              is_xml = is_distinct && Brick.relations[sel_col.first.table_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
+              is_xml = is_distinct && Brick.relations[field_tbl_name]&.[](:cols)&.[](sel_col.last)&.first&.start_with?('xml')
               # If it's not unique then also include the belongs_to association name before the column name
               if used_col_aliases.key?(col_alias = "br_fk_#{v.first}__#{sel_col.last}")
                 col_alias = "br_fk_#{v.first}__#{v1[idx][-2..-1].map(&:to_s).join('__')}"
@@ -659,14 +654,9 @@ module ActiveRecord
           end
         end
         join_array.each do |assoc_name|
-          # %%% Need to support {user: :profile}
           next unless assoc_name.is_a?(Symbol)
 
-          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
+          table_alias = rel_dupe.brick_links[assoc_name.to_s]
           _assoc_names[assoc_name] = [table_alias, klass]
         end
       end
@@ -677,26 +667,47 @@ module ActiveRecord
                          # Build the chain of JOINs going to the final destination HMT table
                          # (Usually just one JOIN, but could be many.)
                          hmt_assoc = hm
-                         x = []
-                         x.unshift(hmt_assoc) while hmt_assoc.options[:through] && (hmt_assoc = klass.reflect_on_association(hmt_assoc.options[:through]))
-                         from_clause = +"#{x.first.table_name} br_t0"
-                         fk_col = x.shift.foreign_key
-                         link_back = [klass.primary_key] # %%% Inverse path back to the original object -- used to build out a link with a filter
+                         through_sources = []
+                         # %%% Inverse path back to the original object -- not yet used, but soon
+                         # will be leveraged in order to build links with multi-table-hop filters.
+                         link_back = []
+                         # Track polymorphic type field if necessary
+                         if hm.source_reflection.options[:as]
+                           poly_ft = [hm.source_reflection.inverse_of.foreign_type, hmt_assoc.source_reflection.class_name]
+                         end
+                         # link_back << hm.source_reflection.inverse_of.name
+                         while hmt_assoc.options[:through] && (hmt_assoc = klass.reflect_on_association(hmt_assoc.options[:through]))
+                           through_sources.unshift(hmt_assoc)
+                         end
+                         # Turn the last member of link_back into a foreign key
+                         link_back << hmt_assoc.source_reflection.foreign_key
+                         # If it's a HMT based on a HM -> HM, must JOIN the last table into the mix at the end
+                         through_sources.push(hm.source_reflection) unless hm.source_reflection.belongs_to?
+                         from_clause = +"#{through_sources.first.table_name} br_t0"
+                         fk_col = through_sources.shift.foreign_key
+
                          idx = 0
                          bail_out = nil
-                         x.map do |a|
+                         through_sources.map do |a|
                            from_clause << "\n LEFT OUTER JOIN #{a.table_name} br_t#{idx += 1} "
                            from_clause << if (src_ref = a.source_reflection).macro == :belongs_to
+                                            (nm = hmt_assoc.source_reflection.inverse_of&.name)
+                                            # binding.pry unless nm
+                                            link_back << nm
                                             "ON br_t#{idx}.id = br_t#{idx - 1}.#{a.foreign_key}"
                                           elsif src_ref.options[:as]
                                             "ON br_t#{idx}.#{src_ref.type} = '#{src_ref.active_record.name}'" + # "polymorphable_type"
                                             " AND br_t#{idx}.#{src_ref.foreign_key} = br_t#{idx - 1}.id"
                                           elsif src_ref.options[:source_type]
-                                            print "Skipping #{hm.name} --HMT-> #{hm.source_reflection.name} as it uses source_type which is not supported"
+                                            print "Skipping #{hm.name} --HMT-> #{hm.source_reflection.name} as it uses source_type which is not yet supported"
                                             nix << k
                                             bail_out = true
                                             break
                                           else # Standard has_many
+                                            # binding.pry unless (
+                                            nm = hmt_assoc.source_reflection.inverse_of&.name
+                                            # )
+                                            link_back << nm # if nm
                                             "ON br_t#{idx}.#{a.foreign_key} = br_t#{idx - 1}.id"
                                           end
                            link_back.unshift(a.source_reflection.name)
@@ -704,6 +715,7 @@ module ActiveRecord
                          end
                          next if bail_out
 
+                         # puts "LINK BACK! #{k} : #{hm.table_name} #{link_back.map(&:to_s).join('.')}"
                          # count_column is determined from the originating HMT member
                          if (src_ref = hm.source_reflection).nil?
                            puts "*** Warning:  Could not determine destination model for this HMT association in model #{klass.name}:\n  has_many :#{hm.name}, through: :#{hm.options[:through]}"
@@ -711,8 +723,10 @@ module ActiveRecord
                            nix << k
                            next
                          elsif src_ref.macro == :belongs_to # Traditional HMT using an associative table
+                           # binding.pry if link_back.length > 2
                            "br_t#{idx}.#{hm.foreign_key}"
                          else # A HMT that goes HM -> HM, something like Categories -> Products -> LineItems
+                           # binding.pry if link_back.length > 2
                            "br_t#{idx}.#{src_ref.active_record.primary_key}"
                          end
                        else
@@ -776,8 +790,7 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
           if (v_parts = v.first.split('.')).length == 1
             s[v.first] = v.last
           else
-            k1 = klass.reflect_on_association(v_parts.first)&.klass
-            tbl_name = (field_tbl_names[v_parts.first][k1] ||= shift_or_first(chains[k1])).split('.').last
+            tbl_name = rel_dupe.brick_links[v_parts.first].split('.').last
             s["#{tbl_name}.#{v_parts.last}"] = v.last
           end
         end

data/lib/brick/version_number.rb

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

data/lib/brick.rb

@@ -1052,6 +1052,40 @@ ActiveSupport.on_load(:active_record) do
     end
   end
 
+  class ActiveRecord::Associations::JoinDependency
+    if JoinBase.instance_method(:initialize).arity == 2 # Older ActiveRecord 4.x?
+      def initialize(base, associations, joins)
+        @alias_tracker = ::ActiveRecord::Associations::AliasTracker.create(base.connection, joins)
+        @alias_tracker.aliased_table_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
+        tree = self.class.make_tree associations
+
+        # Provide a way to find the original relation that this tree is being used for
+        # (so that we can maintain a list of links for all tables used in JOINs)
+        if (relation = associations.instance_variable_get(:@relation))
+          tree.instance_variable_set(:@relation, relation)
+        end
+
+        @join_root = JoinBase.new base, build(tree, base)
+        @join_root.children.each { |child| construct_tables! @join_root, child }
+      end
+
+    else # For ActiveRecord 5.0 - 7.1
+
+      def initialize(base, table, associations, join_type = nil)
+        tree = self.class.make_tree associations
+
+        # Provide a way to find the original relation that this tree is being used for
+        # (so that we can maintain a list of links for all tables used in JOINs)
+        if (relation = associations.instance_variable_get(:@relation))
+          tree.instance_variable_set(:@relation, relation)
+        end
+
+        @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type if join_type
+      end
+    end
+  end
+
   # First part of arel_table_type stuff:
   # ------------------------------------
   # (more found below)
@@ -1178,7 +1212,7 @@ if ActiveRecord.version < ::Gem::Version.new('5.2')
 
     module Associations
       # Specific to AR 4.2 - 5.1:
-      if Associations.const_defined?('JoinDependency') && JoinDependency.private_instance_methods.include?(:table_aliases_for)
+      if self.const_defined?('JoinDependency') && JoinDependency.private_instance_methods.include?(:table_aliases_for)
         class JoinDependency
         private
 
@@ -1230,4 +1264,91 @@ if ActiveRecord.version < ::Gem::Version.new('5.2')
   # rubocop:enable Style/CommentedKeyword
 end
 
+module ActiveRecord
+  module QueryMethods
+  private
+
+    if private_instance_methods.include?(:build_join_query)
+      alias _brick_build_join_query build_join_query
+      def build_join_query(manager, buckets, *args)
+        # %%% Better way to bring relation into the mix
+        if (aj = buckets.fetch(:association_join, nil))
+          aj.instance_variable_set(:@relation, self)
+        end
+
+        _brick_build_join_query(manager, buckets, *args)
+      end
+
+    else
+
+      alias _brick_select_association_list select_association_list
+      def select_association_list(associations, stashed_joins = nil)
+        result = _brick_select_association_list(associations, stashed_joins)
+        result.instance_variable_set(:@relation, self)
+        result
+      end
+    end
+  end
+
+  # require 'activerecord/associations/join_dependency'
+  module Associations
+    # For AR >= 4.2
+    if self.const_defined?('JoinDependency')
+      class JoinDependency
+      private
+
+        # %%% Pretty much have to flat-out replace this guy (I think anyway)
+        # Good with Rails 5.24 and 7 on this
+        def build(associations, base_klass, root = nil, path = '')
+          root ||= associations
+          associations.map do |name, right|
+            reflection = find_reflection base_klass, name
+            reflection.check_validity!
+            reflection.check_eager_loadable!
+
+            if reflection.polymorphic?
+              raise EagerLoadPolymorphicError.new(reflection)
+            end
+
+            # %%% The path
+            link_path = path.blank? ? name.to_s : path + ".#{name}"
+            ja = JoinAssociation.new(reflection, build(right, reflection.klass, root, link_path))
+            ja.instance_variable_set(:@link_path, link_path) # Make note on the JoinAssociation of its AR path
+            ja.instance_variable_set(:@assocs, root)
+            ja
+          end
+        end
+
+        if JoinDependency.private_instance_methods.include?(:table_aliases_for)
+          # No matter if it's older or newer Rails, now extend so that we can associate AR links to table_alias names
+          alias _brick_table_aliases_for table_aliases_for
+          def table_aliases_for(parent, node)
+            result = _brick_table_aliases_for(parent, node)
+
+            # Capture the table alias name that was chosen
+            link_path = node.instance_variable_get(:@link_path)
+            if (relation = node.instance_variable_get(:@assocs)&.instance_variable_get(:@relation))
+              relation.brick_links[link_path] = result.first.table_alias || result.first.table_name
+            end
+
+            result
+          end
+        else # Same idea but for Rails 7
+          alias _brick_make_constraints make_constraints
+          def make_constraints(parent, child, join_type)
+            result = _brick_make_constraints(parent, child, join_type)
+
+            # Capture the table alias name that was chosen
+            link_path = child.instance_variable_get(:@link_path)
+            relation = child.instance_variable_get(:@assocs)&.instance_variable_get(:@relation)
+            # binding.pry if relation
+            relation.brick_links[link_path] = result.first.left.table_alias || result.first.left.table_name
+            result
+          end
+        end
+      end
+    end
+  end
+end
+
 require 'brick/extensions'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brick
 version: !ruby/object:Gem::Version
-  version: 1.0.91
+  version: 1.0.92
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-09 00:00:00.000000000 Z
+date: 2022-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord