brick 1.0.127 → 1.0.128

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a424ad95046c33fae8463661b1fb53d770e44e37b503cb68b30fce5725c5ebd
-  data.tar.gz: 2fc4b004e49497b1b15c864a646717c162e7d7d55edf6913e916fab86ebbcbb7
+  metadata.gz: 4465179ddef5435627439c7123bbb63e951abcda5bd8bd8e20952cca2fc9e274
+  data.tar.gz: b567eb687c8eea355ece80562a67e424629df4a8b64aae48596e6c6b01c730b4
 SHA512:
-  metadata.gz: 5ebf6939ba66e746baf8c84b347630ec4e68951b23dc1efcd72bff47b3b6550c3c8d3444194489aa227a3be153b387552951fdd0fec03dc66a73306df6d6f0d4
-  data.tar.gz: e3a90e24d98d3bcb47d09e628df9958b101f8dfb9998c97307b791664e8a8b429d12febe73a1e3e322ef3aab054a9e0a103614f2053f58f1b0d2d3e580c9c083
+  metadata.gz: 162cf46af2e43b2652e59f9fe8f4d2826e490def50fb868869f614aacb256cfeecee3833dfb41807bef5ea64c83e921b7e993e728e6e42730a214ec49601de67
+  data.tar.gz: 15fdcc9b67bc82b55a195168e020575ca04d9d1ae5830e0d1bcd2c7e04944aba90238342cabc1c93b7b7d01619a369b1bb0a0383dbbe91666e796ffa4051aa55

data/lib/brick/extensions.rb

@@ -108,16 +108,16 @@ module ActiveRecord
       dsl
     end
 
-    def self.brick_parse_dsl(build_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
-      unless build_array.is_a?(::Brick::JoinArray)
-        build_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([build_array]) } if build_array.is_a?(::Brick::JoinHash)
-        build_array = ::Brick::JoinArray.new unless build_array.nil? || build_array.is_a?(Array)
+    def self.brick_parse_dsl(join_array = nil, prefix = [], translations = {}, is_polymorphic = false, dsl = nil, emit_dsl = false)
+      unless join_array.is_a?(::Brick::JoinArray)
+        join_array = ::Brick::JoinArray.new.tap { |ary| ary.replace([join_array]) } if join_array.is_a?(::Brick::JoinHash)
+        join_array = ::Brick::JoinArray.new unless join_array.nil? || join_array.is_a?(Array)
       end
       prefix = [prefix] unless prefix.is_a?(Array)
       members = []
       unless dsl || (dsl = ::Brick.config.model_descrips[name] || brick_get_dsl)
         # With no DSL available, still put this prefix into the JoinArray so we can get primary key (ID) info from this table
-        x = prefix.each_with_object(build_array) { |v, s| s[v.to_sym] }
+        x = prefix.each_with_object(join_array) { |v, s| s[v.to_sym] }
         x[prefix.last] = nil unless prefix.empty? # Using []= will "hydrate" any missing part(s) in our whole series
         return members
       end
@@ -141,7 +141,7 @@ module ActiveRecord
             if first_parts
               if (parts = prefix + first_parts + [parts[-1]]).length > 1 && klass
                 unless is_polymorphic
-                  s = build_array
+                  s = join_array
                   parts[0..-3].each { |v| s = s[v.to_sym] }
                   s[parts[-2]] = nil # unless parts[-2].empty? # Using []= will "hydrate" any missing part(s) in our whole series
                 end
@@ -153,7 +153,7 @@ module ActiveRecord
                   prefix << parts.shift until parts.empty?
                 end
                 # Expand this entry which refers to an association name
-                members2, dsl2a = klass.brick_parse_dsl(build_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
+                members2, dsl2a = klass.brick_parse_dsl(join_array, prefix + [possible_dsl], translations, is_polymorphic, nil, true)
                 members += members2
                 dsl2 << dsl2a
                 dsl3 << dsl2a
@@ -434,7 +434,9 @@ module ActiveRecord
       @brick_links ||= { '' => table_name }
     end
 
-    def brick_select(params, selects = [], order_by = nil, translations = {}, join_array = ::Brick::JoinArray.new)
+    def brick_select(params, selects = [], order_by = nil, translations = {},
+                     join_array = ::Brick::JoinArray.new,
+                     cust_col_override = nil)
       is_add_bts = is_add_hms = true
 
       # Build out cust_cols, bt_descrip and hm_counts now so that they are available on the
@@ -467,7 +469,7 @@ module ActiveRecord
           is_distinct = true
           distinct!
         end
-        wheres[k] = v.split(',')
+        wheres[k] = v.is_a?(String) ? v.split(',') : v
       end
 
       # %%% Skip the metadata columns
@@ -506,84 +508,90 @@ module ActiveRecord
         end
       end
 
-      if join_array.present?
-        left_outer_joins!(join_array)
-        # Touching AREL AST walks the JoinDependency tree, and in that process uses our
-        # "brick_links" patch to find how every AR chain of association names relates to exact
-        # table correlation names chosen by AREL.  We use a duplicate relation object for this
-        # because an important side-effect of referencing the AST is that the @arel instance
-        # variable gets set, and this is a signal to ActiveRecord that a relation has now
-        # become immutable.  (We aren't quite ready for our "real deal" relation object to be
-        # set in stone ... still need to add .select(), and possibly .where() and .order()
-        # things ... also if there are any HM counts then an OUTER JOIN for each of them out
-        # to a derived table to do that counting.  All of these things need to know proper
-        # table correlation names, which will now become available in brick_links on the
-        # rel_dupe object.)
-        (rel_dupe = dup).arel.ast
-
-        core_selects = selects.dup
-        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
-
-        # CUSTOM COLUMNS
-        # ==============
-        klass._br_cust_cols.each do |k, cc|
-          if rel_dupe.respond_to?(k) # Name already taken?
-            # %%% Use ensure_unique here in this kind of fashion:
-            # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
-            # binding.pry
-            next
-          end
+      left_outer_joins!(join_array) if join_array.present?
+
+      # If it's a CollectionProxy (which inherits from Relation) then need to dig out the
+      # core Relation object which is found in the association scope.
+      rel_dupe = (is_a?(ActiveRecord::Associations::CollectionProxy) ? scope : self).dup
+
+      # Touching AREL AST walks the JoinDependency tree, and in that process uses our
+      # "brick_links" patch to find how every AR chain of association names relates to exact
+      # table correlation names chosen by AREL.  We use a duplicate relation object for this
+      # because an important side-effect of referencing the AST is that the @arel instance
+      # variable gets set, and this is a signal to ActiveRecord that a relation has now
+      # become immutable.  (We aren't quite ready for our "real deal" relation object to be
+      # set in stone ... still need to add .select(), and possibly .where() and .order()
+      # things ... also if there are any HM counts then an OUTER JOIN for each of them out
+      # to a derived table to do that counting.  All of these things need to know proper
+      # table correlation names, which will now become available in brick_links on the
+      # rel_dupe object.)
+      rel_dupe.arel.ast
+
+      core_selects = selects.dup
+      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
+
+      # CUSTOM COLUMNS
+      # ==============
+      (cust_col_override || klass._br_cust_cols).each do |k, cc|
+        if rel_dupe.respond_to?(k) # Name already taken?
+          # %%% Use ensure_unique here in this kind of fashion:
+          # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", bts, hms)
+          # binding.pry
+          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) do |kl, cc_part_term|
-              # %%% Clear column info properly so we can do multiple subsequent requests
-              # binding.pry unless kl.reflect_on_association(cc_part_term)
-              kl.reflect_on_association(cc_part_term)&.klass || klass
-            end
-            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".
-            if (cc_part_idx = cc_part.length - 1).zero?
-              col_alias = "br_cc_#{k}__#{table_name.tr('.', '_')}"
-            else
-              while cc_part_idx > 0 &&
-                    (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
-                    used_col_aliases.key?(col_alias)
-                cc_part_idx -= 1
-              end
-            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
+        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) do |kl, cc_part_term|
+            # %%% Clear column info properly so we can do multiple subsequent requests
+            # binding.pry unless kl.reflect_on_association(cc_part_term)
+            kl.reflect_on_association(cc_part_term)&.klass || klass
+          end
+          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".
+          if (cc_part_idx = cc_part.length - 1).zero?
+            col_alias = "br_cc_#{k}__#{table_name.tr('.', '_')}_#{cc_part.first}"
+          else
+            while cc_part_idx > 0 &&
+                  (col_alias = "br_cc_#{k}__#{cc_part[cc_part_idx..-1].map(&:to_s).join('__').tr('.', '_')}") &&
+                  used_col_aliases.key?(col_alias)
+              cc_part_idx -= 1
             end
-            selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
-            cc_part << col_alias
           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
+          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
-          cc[2] = key_alias ? [key_klass, key_alias] : nil
+          selects << "#{tbl_name}.#{cc_part.last} AS #{col_alias}"
+          cc_part << col_alias
         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
 
+      # LEFT OUTER JOINs
+      unless cust_col_override
         klass._br_bt_descrip.each do |v|
           v.last.each do |k1, v1| # k1 is class, v1 is array of columns to snag
             next unless (tbl_name = rel_dupe.brick_links[v.first.to_s]&.split('.')&.last)
@@ -644,6 +652,7 @@ module ActiveRecord
           _assoc_names[assoc_name] = [table_alias, klass]
         end
       end
+
       # Add derived table JOIN for the has_many counts
       nix = []
       klass._br_hm_counts.each do |k, hm|
@@ -781,7 +790,7 @@ module ActiveRecord
 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}"
         self.joins_values |= ["#{join_clause} ON #{on_clause.join(' AND ')}"] # Same as:  joins!(...)
-      end
+      end unless cust_col_override
       while (n = nix.pop)
         klass._br_hm_counts.delete(n)
       end
@@ -851,6 +860,19 @@ JOIN (SELECT #{hm_selects.map { |s| "#{'br_t0.' if from_clause}#{s}" }.join(', '
       wheres unless wheres.empty? # Return the specific parameters that we did use
     end
 
+    # Build out an AR relation that queries for a list of objects, and include all the appropriate JOINs to later apply DSL using #brick_descrip
+    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) }
+      pieces, my_dsl = klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
+      brick_select(
+        where_values_hash, selects, nil, translations, join_array,
+        { '_br' => (descrip_cols = [pieces, my_dsl]) }
+      )
+      order_values = klass.primary_key
+      [self.select(selects), descrip_cols]
+    end
+
   private
 
     def shift_or_first(ary)
@@ -1254,6 +1276,11 @@ class Object
           end
           self.abstract_class = true
           code << "  self.abstract_class = true\n"
+        elsif Object.const_defined?('BCrypt') && relation[:cols].include?('password_digest') &&
+              !instance_methods.include?(:password) && respond_to?(:has_secure_password)
+          puts "Appears that the #{full_name} model is intended to hold user account information.  Applying #has_secure_password."
+          has_secure_password
+          code << "  has_secure_password\n"
         end
         # Accommodate singular or camel-cased table names such as "order_detail" or "OrderDetails"
         code << "  self.table_name = '#{self.table_name = matching}'\n" if inheritable_name || table_name != matching
@@ -2718,12 +2745,17 @@ module Brick
                  end
                end
       ::Brick.relations.map do |k, v|
+        # next if Brick.config.exclude_tables.include?(k)
+
         tbl_parts = k.split('.')
         tbl_parts.shift if ::Brick.apartment_multitenant && tbl_parts.length > 1 && tbl_parts.first == ::Brick.apartment_default_tenant
         res = tbl_parts.join('.')
-        [k, (model = models[res])&.last&.table_name || v[:class_name].constantize.table_name,
-            migrations&.fetch(res, nil),
-            model&.first]
+        table_name = (model = models[res])&.last&.table_name
+        table_name ||= begin
+                         v[:class_name].constantize.table_name
+                       rescue
+                       end
+        [k, table_name || k, migrations&.fetch(res, nil), model&.first]
       end
     end
 

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

@@ -1602,7 +1602,15 @@ end
         if bt.length < 4
           bt << (option_detail = [[\"(No #\{bt_name\} chosen)\", '^^^brick_NULL^^^']])
           # %%% Accommodate composite keys for obj.pk at the end here
-          bt_class&.order(obj_pk = bt_class.primary_key)&.each { |obj| option_detail << [obj.brick_descrip(nil, obj_pk), obj.send(obj_pk)] }
+          collection, descrip_cols = bt_class&.order(obj_pk = bt_class.primary_key).brick_list
+          collection&.each do |obj|
+            option_detail << [
+              obj.brick_descrip(
+                descrip_cols&.first&.map { |col| obj.send(col.last) },
+                obj_pk
+              ), obj.send(obj_pk)
+            ]
+          end
         end %>
         BT <%= bt_class&.bt_link(bt.first) || orig_poly_name %>
     <% else %>
@@ -1634,34 +1642,45 @@ end
       obj_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "#{hm_singular_name}.#{pk_part}" }.join(', ')
       poly_fix = if (poly_type = (hm.first.options[:as] && hm.first.type))
                    "
-                       # Let's fix an unexpected \"feature\" of AR -- when going through a polymorphic has_many
-                       # association that points to an STI model then filtering for the __able_type column is done
-                       # with a .where(). And the polymorphic class name it points to is the base class name of
-                       # the STI model instead of its subclass.
-                       poly_type = #{poly_type.inspect}
-#{                     (inh_col = @_brick_model.inheritance_column).present? &&
-"                      if poly_type && @#{obj_name}.respond_to?(:#{inh_col}) &&
-                          (base_type = collection.where_values_hash[poly_type])
-                         collection = collection.rewhere(poly_type => [base_type, @#{obj_name}.#{inh_col}])
-                       end"}"
+                     # Let's fix an unexpected \"feature\" of AR -- when going through a polymorphic has_many
+                     # association that points to an STI model then filtering for the __able_type column is done
+                     # with a .where(). And the polymorphic class name it points to is the base class name of
+                     # the STI model instead of its subclass.
+                     poly_type = #{poly_type.inspect}
+#{                   (inh_col = @_brick_model.inheritance_column).present? &&
+"                    if poly_type && @#{obj_name}.respond_to?(:#{inh_col}) &&
+                        (base_type = collection.where_values_hash[poly_type])
+                       collection = collection.rewhere(poly_type => [base_type, @#{obj_name}.#{inh_col}])
+                     end"}"
                  end
       s << "<table id=\"#{hm_name}\" class=\"shadow\">
         <tr><th>#{hm[1]}#{' poly' if hm[0].options[:as]} #{hm[3]}</th></tr>
-        <% collection = @#{obj_name}.#{hm_name}
-        collection = case collection
-                     when ActiveRecord::Associations::CollectionProxy#{
-                       poly_fix}
-                       collection.order(#{pk.inspect})
-                     when ActiveRecord::Base # Object from a has_one
-                       [collection]
-                     else # We get an array back when AR < 4.2
-                       collection.to_a.compact
-                     end
-        if collection.empty? %>
+        <% 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 = collection.instance_exec(&assoc.scopes.first) if assoc.scopes.present?
+           else
+             collection = @#{obj_name}.#{hm_name}
+           end
+        case collection
+        when ActiveRecord::Relation # has_many (which comes in as a CollectionProxy) or a has_one#{
+          poly_fix}
+          collection2, descrip_cols = collection.brick_list
+        when ActiveRecord::Base # Object from a has_one :through
+          collection2 = [collection]
+        else # We get an array back when AR < 4.2
+          collection2 = collection.to_a.compact
+        end
+        collection2 = collection2.uniq
+        if collection2.empty? %>
           <tr><td>(none)</td></tr>
-        <% else %>
-          <% collection.uniq.each do |#{hm_singular_name}| %>
-            <tr><td><%= link_to(#{hm_singular_name}.brick_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
+     <% else
+          collection2.each do |#{hm_singular_name}| %>
+            <tr><td><%= br_descrip = #{hm_singular_name}.brick_descrip(
+                                       descrip_cols&.first&.map { |col| #{hm_singular_name}.send(col.last) }
+                                     )
+                        link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_pk}))) %></td></tr>
           <% end %>
         <% end %>
       </table>"

data/lib/brick/version_number.rb

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

metadata

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