brick 1.0.90 → 1.0.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eca72d418715811a100a44a45b3cd054ca511ed280f1d1a6f344ddaa972c220c
-  data.tar.gz: d712ebb5dedf75da99d8d8720f4b89e29ea2e96b498b4a59540811f5e087231c
+  metadata.gz: 6bb6854dd2295476ae00996f23e801587869463aa7114d9240c0e97b1cce25b1
+  data.tar.gz: f174948106c6a06be049f8285fb3358813d09b9970ce484554ad3c86bc3cb8fb
 SHA512:
-  metadata.gz: 1b3d3941f4905b7a3ce1489a6f018d958331bd4c2970a5ba5034eb0fb81683febdc8a93562be5a1505afe6d6479fb1ed068a0f21d6ea80f24460e9e9267b8ea3
-  data.tar.gz: c3f61b68cd2ca5790f93b82010909f65913ccecb46df24786c83db362241092824db66833b72f03708560f23b7e87f64f12b180d8e4fb9ababba32bdb9b3f9df
+  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

@@ -309,9 +309,15 @@ module ActiveRecord
     def self._brick_calculate_bts_hms(translations, join_array)
       # Add any custom columns
       ::Brick.config.custom_columns&.fetch(table_name, nil)&.each do |k, cc|
+        if cc.is_a?(Array)
+          fk_col = cc.last unless cc.last.blank?
+          cc = cc.first
+        else
+          fk_col = true
+        end
         # false = not polymorphic, and true = yes -- please emit_dsl
         pieces, my_dsl = brick_parse_dsl(join_array, [], translations, false, cc, true)
-        _br_cust_cols[k] = [pieces, my_dsl]
+        _br_cust_cols[k] = [pieces, my_dsl, fk_col]
       end
       bts, hms, associatives = ::Brick.get_bts_and_hms(self)
       bts.each do |_k, bt|
@@ -401,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 = '')
@@ -442,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
@@ -451,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
@@ -542,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
@@ -557,9 +563,13 @@ module ActiveRecord
             next
           end
 
+          key_klass = nil
+          key_tbl_name = nil
+          dest_pk = nil
+          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".
@@ -569,31 +579,45 @@ module ActiveRecord
                   used_col_aliases.key?(col_alias)
               cc_part_idx -= 1
             end
+            used_col_aliases[col_alias] = nil
+            # Set up custom column links by preparing key_klass and key_alias
+            # (If there are multiple different tables referenced in the DSL, we end up creating a link to the last one)
+            if cc[2] && (dest_pk = dest_klass.primary_key)
+              key_klass = dest_klass
+              key_tbl_name = tbl_name
+              cc_part_idx = cc_part.length - 1
+              while cc_part_idx > 0 &&
+                    (key_alias = "br_cc_#{k}__#{(cc_part[cc_part_idx..-2] + [dest_pk]).map(&:to_s).join('__')}") &&
+                    key_alias != col_alias && # We break out if this key alias does exactly match the col_alias
+                    used_col_aliases.key?(key_alias)
+                cc_part_idx -= 1
+              end
+            end
             selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
             cc_part << col_alias
-            used_col_aliases[col_alias] = nil
           end
+          # Add a key column unless we've already got it
+          if key_alias && !used_col_aliases.key?(key_alias)
+            selects << "#{key_tbl_name}.#{dest_pk} AS #{key_alias}"
+            used_col_aliases[key_alias] = nil
+          end
+          cc[2] = key_alias ? [key_klass, key_alias] : nil
         end
 
         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('__')}"
@@ -630,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
@@ -648,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)
@@ -675,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]}"
@@ -682,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
@@ -747,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
@@ -1167,7 +1209,7 @@ class Object
       if (base_model = ::Brick.sti_models[full_model_name]&.fetch(:base, nil) || ::Brick.existing_stis[full_model_name]&.constantize)
         is_sti = true
       else
-        base_model = ::Brick.config.models_inherit_from || ActiveRecord::Base
+        base_model = ::Brick.config.models_inherit_from
       end
       hmts = nil
       code = +"class #{full_name} < #{base_model.name}\n"

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

@@ -19,7 +19,12 @@ module Brick
         ::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)
+        ::Brick.models_inherit_from = app.config.brick.fetch(:models_inherit_from, nil) ||
+                                      begin
+                                        ::ApplicationRecord
+                                      rescue StandardError => ex
+                                        ::ActiveRecord::Base
+                                      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, [])
@@ -985,7 +990,12 @@ erDiagram
     %><%=  display_value(col_type || col&.sql_type, val) %><%
          elsif cust_col
            data = cust_col.first.map { |cc_part| #{obj_name}.send(cc_part.last) }
-    %><%=  #{model_name}.brick_descrip(cust_col.last, data) %><%
+           cust_txt = #{model_name}.brick_descrip(cust_col[-2], data)
+           if (link_id = #{obj_name}.send(cust_col.last[1]) if cust_col.last)
+    %><%=    link_to(cust_txt, send(\"#\{cust_col.last.first._brick_index(:singular)}_path\", link_id)) %><%
+           else
+    %><%=    cust_txt %><%
+           end
          else # Bad column name!
       %>?<%
          end

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 90
+    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'

data/lib/generators/brick/install_generator.rb

@@ -139,7 +139,7 @@ module Brick
 # Settings for the Brick gem
 # (By default this auto-creates models, controllers, views, and routes on-the-fly.)
 
-if Object.const_defined?('Brick')
+if ActiveRecord::Base.respond_to?(:brick_select)
   # Mode -- generally :on or :off, or only in :development.  Also available is :diag_env which enables only
   # when the environment variable BRICK is set.
   Brick.mode = :development

metadata

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