brick 1.0.209 → 1.0.211

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9727d5ff3dbf5edcb8ce91b03d0570eec5eb2e0f9ae2c4f456d9d50779321fc9
-  data.tar.gz: 32b32f909110d6eca464c775d9725ad049fabf8591daab1088da007ae9a95c5a
+  metadata.gz: 7950119f788fe1cac3fde68806f2b4a1145da0cf17ff0d47363b102be9c69933
+  data.tar.gz: 33bb7d89a0744890d4450afde332dbd0f0635a8d3acd0beb4107cf4e44ff9718
 SHA512:
-  metadata.gz: 1931290e472f472d93e1536e6517a3865bcc1acd23d15156d48e52c7f35987183b274c8a7c2ac00f09f2f6ac9a4d5663071c84ae4c896de6b4c0069d4a06b1da
-  data.tar.gz: 5064ef883fb66feb187fe80a92b3ec700da04feef0f390d720b51497f086bbc1062e505cd467d3624fadb6102bc8dec49b0b6b16a1c04a1a1ceb34e50f4f9ff5
+  metadata.gz: 959c6ada7e03de34f566ad6059a4431ea66d2be9f12764de3edb3760074a70f3e91354e9052bc3c1a74eed4d5d7a274a78cf490195815b736b02f282ffe03d47
+  data.tar.gz: a87abaf8c878fecda93fc6751bae171e5194b6b63d933f83ba331191aee701859d3022754f68af3d730c25add0cc0a8174246fd18913040bed75ec700ba2b543

data/lib/brick/extensions.rb

@@ -72,7 +72,7 @@ module ActiveRecord
 
       def real_model(params)
         if params && (sub_model = params.fetch(type_col = inheritance_column, nil))
-          sub_model = sub_model.first if sub_model.is_a?(Array) # Support the params style that gets returned from #brick_select
+          sub_model = sub_model.first if sub_model.is_a?(Array) # Support the params style that gets returned from #_brick_querying
           # Make sure the chosen model is really the same or a subclass of this model
           (possible_model = sub_model.constantize) <= self ? possible_model : self
         else
@@ -92,11 +92,49 @@ module ActiveRecord
         reflect_on_association(assoc).foreign_type || "#{assoc}_type"
       end
 
-      def _brick_all_fields
-        rtans = if respond_to?(:rich_text_association_names)
-                  rich_text_association_names&.map { |rtan| rtan.to_s.start_with?('rich_text_') ? rtan[10..-1] : rtan }
-                end
-        columns_hash.keys.map(&:to_sym) + (rtans || [])
+      def _brick_all_fields(skip_id = nil)
+        col_names = columns_hash.keys
+        # If it's a composite primary key then allow all the values through
+        # TODO: Should disallow any autoincrement / SERIAL columns
+        if skip_id && (pk_as_array = _pk_as_array).length == 1
+          col_names -= _pk_as_array
+        end
+        hoa, hma, rtans = _activestorage_actiontext_fields
+        col_names.map(&:to_sym) + hoa + hma.map { |as| { as => [] } } + rtans.values
+      end
+
+      # Return three lists of fields for this model --
+      # has_one_attached, has_many_attached, and has_rich_text
+      def _activestorage_actiontext_fields
+        fields = [[], [], {}]
+        if !(self <= ActiveStorage::Blob) && respond_to?(:generated_association_methods) # ActiveStorage
+          generated_association_methods.instance_methods.each do |method_sym|
+            method_str = method_sym.to_s
+            fields[0] << method_str[0..-13].to_sym if method_str.end_with?('_attachment=') # has_one_attached
+            fields[1] << method_str[0..-14].to_sym if method_str.end_with?('_attachments=') # has_many_attached
+          end
+        end
+        if respond_to?(:rich_text_association_names) # ActionText
+          rich_text_association_names&.each do |rtan| # has_rich_text
+            rtan_str = rtan.to_s
+            fields[2][rtan] = rtan_str.start_with?('rich_text_') ? rtan_str[10..-1].to_sym : rtan
+          end
+        end
+        fields
+      end
+
+      def _active_storage_name(col_name)
+        if Object.const_defined?('ActiveStorage') && (self <= ActiveStorage::Attachment || self <= ActiveStorage::Blob)
+          if (col_str = col_name.to_s).end_with?('_attachments')
+            col_str[0..-13]
+          elsif col_str.end_with?('_blobs')
+            col_str[0..-7]
+          end
+        end
+      end
+
+      def _pk_as_array
+        self.primary_key.is_a?(Array) ? self.primary_key : [self.primary_key]
       end
 
       def _br_quoted_name(name)
@@ -147,8 +185,8 @@ module ActiveRecord
           skip_columns = _brick_get_fks + (::Brick.config.metadata_columns || []) + [primary_key]
           dsl = if (descrip_col = columns.find { |c| [:boolean, :binary, :xml].exclude?(c.type) && skip_columns.exclude?(c.name) })
                   "[#{descrip_col.name}]"
-                elsif (pk_parts = self.primary_key.is_a?(Array) ? self.primary_key : [self.primary_key])
-                  "#{name} ##{pk_parts.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
+                else
+                  "#{name} ##{_pk_as_array.map { |pk_part| "[#{pk_part}]" }.join(', ')}"
                 end
           ::Brick.config.model_descrips[name] = dsl
         end
@@ -491,17 +529,12 @@ module ActiveRecord
       [order_by, order_by_txt]
     end
 
-    def self.brick_select(*args, params: {}, brick_col_names: false, **kwargs)
-      selects = if args[0].is_a?(Array)
-                  other_args = args[1..-1]
-                  args[0]
-                else
-                  other_args = []
-                  args
-                end
-      (relation = all).brick_select(selects, *other_args,
-                                    params: params, brick_col_names: brick_col_names, **kwargs)
-      relation.select(selects)
+    def self.brick_select(*args, **kwargs)
+      all.brick_select(*args, **kwargs)
+    end
+
+    def self.brick_pluck(*args, withhold_ids: true, **kwargs)
+      all.brick_pluck(*args, withhold_ids: withhold_ids, **kwargs)
     end
 
     def self.brick_where(*args)
@@ -559,7 +592,7 @@ module ActiveRecord
                           # 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.
                           brick_rel = is_a?(ActiveRecord::Associations::CollectionProxy) ? scope : self
-                          brick_rel = brick_rel.dup if do_dup
+                          brick_rel = (@_brick_rel_dup ||= brick_rel.dup) if do_dup
                           # Start out with a hash that has only the root table name
                           brick_rel.instance_variable_set(:@_brick_links, bl = { '' => table_name })
                           brick_rel.arel.ast if do_dup # Walk the AST tree in order to capture all the other correlation names
@@ -567,10 +600,22 @@ module ActiveRecord
                         end
     end
 
-    def brick_select(*args, params: {}, order_by: nil, translations: {},
-                     join_array: ::Brick::JoinArray.new,
-                     cust_col_override: nil,
-                     brick_col_names: true)
+    def brick_select(*args, **kwargs)
+      selects = args[0].is_a?(Array) ? args[0] : args
+      _brick_querying(selects, **kwargs)
+      select(selects)
+    end
+
+    def brick_pluck(*args, withhold_ids: true, **kwargs)
+      selects = args[0].is_a?(Array) ? args[0] : args
+      _brick_querying(selects, withhold_ids: withhold_ids, **kwargs)
+      pluck(selects)
+    end
+
+    def _brick_querying(*args, withhold_ids: nil, params: {}, order_by: nil, translations: {},
+                        join_array: ::Brick::JoinArray.new,
+                        cust_col_override: nil,
+                        brick_col_names: nil)
       selects = args[0].is_a?(Array) ? args[0] : args
       if selects.present? && cust_col_override.nil? # See if there's any fancy ones in the select list
         idx = 0
@@ -654,13 +699,13 @@ module ActiveRecord
                        "'<#{typ.end_with?('_TYP') ? typ[0..-5] : typ}>' AS #{col.name}"
                      end
         end
-      else # Having some select columns chosen, add any missing always_load_fields for this model ...
+      elsif !withhold_ids # Having some select columns chosen, add any missing always_load_fields for this model ...
         this_model = klass
         loop do
           ::Brick.config.always_load_fields.fetch(this_model.name, nil)&.each do |alf|
             selects << alf unless selects.include?(alf)
           end
-          # ... plus any and all STI superclasses it may inherit from
+          # ... plus ALF fields from any and all STI superclasses it may inherit from
           break if (this_model = this_model.superclass).abstract_class? || this_model == ActiveRecord::Base
         end
       end
@@ -673,15 +718,16 @@ module ActiveRecord
         end
       end
 
-      core_selects = selects.dup
+      # 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 respond_to?(k) # Name already taken?
+      (cust_col_override || (!withhold_ids && klass._br_cust_cols))&.each do |k, cc|
+        brick_links # Intentionally create a relation duplicate
+        if @_brick_rel_dup.respond_to?(k) # Name already taken?
           # %%% Use ensure_unique here in this kind of fashion:
           # cnstr_name = ensure_unique(+"(brick) #{for_tbl}_#{pri_tbl}", nil, bts, hms)
           # binding.pry
@@ -730,12 +776,14 @@ module ActiveRecord
           selects << "#{_br_quoted_name(tbl_name)}.#{_br_quoted_name(cc_part.last)} AS #{_br_quoted_name(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 << "#{_br_quoted_name(key_tbl_name)}.#{_br_quoted_name(dest_pk)} AS #{_br_quoted_name(key_alias)}"
-          used_col_aliases[key_alias] = nil
+        unless withhold_ids
+          # Add a key column unless we've already got it
+          if key_alias && !used_col_aliases.key?(key_alias)
+            selects << "#{_br_quoted_name(key_tbl_name)}.#{_br_quoted_name(dest_pk)} AS #{_br_quoted_name(key_alias)}"
+            used_col_aliases[key_alias] = nil
+          end
+          cc[2] = key_alias ? [key_klass, key_alias] : nil
         end
-        cc[2] = key_alias ? [key_klass, key_alias] : nil
       end
 
       # LEFT OUTER JOINs
@@ -751,7 +799,7 @@ module ActiveRecord
               # %%% Strangely in Rails 7.1 on a slower system then very rarely brick_link comes back nil...
               brick_link = brick_links[sel_col.first]
               field_tbl_name = brick_link&.split('.')&.last ||
-                # ... so here's a best-effort guess for what the table name might be.
+                # ... so if it is nil then here's a best-effort guess as to what the table name might be.
                 klass.reflect_on_association(sel_col.first)&.klass&.table_name
               # If it's Oracle, quote any AREL aliases that had been applied
               field_tbl_name = "\"#{field_tbl_name}\"" if ::Brick.is_oracle && brick_links.values.include?(field_tbl_name)
@@ -831,6 +879,8 @@ module ActiveRecord
                          end
                          through_sources.push(src_ref) unless src_ref.belongs_to?
                          from_clause = +"#{_br_quoted_name(through_sources.first.table_name)} br_t0"
+                         # ActiveStorage will not get the correct count unless we do some extra filtering later
+                         tbl_nm = 'br_t0' if Object.const_defined?('ActiveStorage') && through_sources.first.klass <= ActiveStorage::Attachment
                          fk_col = through_sources.shift.foreign_key
 
                          idx = 0
@@ -924,10 +974,14 @@ module ActiveRecord
           tbl_nm = hm.macro == :has_and_belongs_to_many ? hm.join_table : hm.table_name
           hm_table_name = _br_quoted_name(tbl_nm)
         end
+        # ActiveStorage has_many_attached needs a bit more filtering
+        if (k_str = hm.klass._active_storage_name(k))
+          where_ct_clause = "WHERE #{_br_quoted_name("#{tbl_nm}.name")} = '#{k_str}' "
+        end
         group_bys = ::Brick.is_oracle || is_mssql ? hm_selects : (1..hm_selects.length).to_a
         join_clause = "LEFT OUTER
 JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#{s}") }.join(', ')}, COUNT(#{'DISTINCT ' if hm.options[:through]}#{_br_quoted_name(count_column)
-          }) AS c_t_ FROM #{from_clause || hm_table_name} GROUP BY #{group_bys.join(', ')}) #{_br_quoted_name(tbl_alias)}"
+          }) AS c_t_ FROM #{from_clause || hm_table_name} #{where_ct_clause}GROUP BY #{group_bys.join(', ')}) #{_br_quoted_name(tbl_alias)}"
         self.joins_values |= ["#{join_clause} ON #{on_clause.join(' AND ')}"] # Same as:  joins!(...)
       end unless cust_col_override
       while (n = nix.pop)
@@ -1022,9 +1076,10 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
       selects << 'customer_id' if klass.name == 'Pay::Subscription' && Pay::Subscription.columns_hash.key?('customer_id')
 
       pieces, my_dsl = klass.brick_parse_dsl(join_array = ::Brick::JoinArray.new, [], translations = {}, false, nil, true)
-      brick_select(
+      _brick_querying(
         selects, where_values_hash, nil, translations: translations, join_array: join_array,
-        cust_col_override: { '_br' => (descrip_cols = [pieces, my_dsl]) }
+        cust_col_override: { '_br' => (descrip_cols = [pieces, my_dsl]) },
+        brick_col_names: true
       )
       order_values = "#{_br_quoted_name(klass.table_name)}.#{_br_quoted_name(klass.primary_key)}"
       [self.select(selects), descrip_cols]
@@ -2246,9 +2301,10 @@ class Object
 
             ar_relation = ActiveRecord.version < Gem::Version.new('4') ? real_model.preload : real_model.all
             params['_brick_is_api'] = true if (is_api = request.format == :js || current_api_root)
-            @_brick_params = ar_relation.brick_select((selects ||= []), params: params, order_by: order_by,
-                                                      translations: (translations = {}),
-                                                      join_array: (join_array = ::Brick::JoinArray.new))
+            @_brick_params = ar_relation._brick_querying((selects ||= []), params: params, order_by: order_by,
+                                                         translations: (translations = {}),
+                                                         join_array: (join_array = ::Brick::JoinArray.new),
+                                                         brick_col_names: true)
 
             if is_api # Asking for JSON?
               # Apply column renaming
@@ -2342,7 +2398,7 @@ class Object
           _, order_by_txt = model._brick_calculate_ordering(default_ordering(table_name, pk, true)) if pk
           code << "  def index\n"
           code << "    @#{plural_table_name} = #{model.name}#{pk&.present? ? ".order(#{order_by_txt.join(', ')})" : '.all'}\n"
-          code << "    @#{plural_table_name}.brick_select(params)\n"
+          code << "    @#{plural_table_name}._brick_querying(params, brick_col_names: true)\n"
           code << "  end\n"
 
           is_pk_string = nil
@@ -2357,6 +2413,8 @@ class Object
             end
           end
 
+          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
+
           # By default, views get marked as read-only
           # unless model.readonly # (relation = relations[model.table_name]).key?(:isView)
           code << "  def new\n"
@@ -2364,7 +2422,11 @@ class Object
           code << "  end\n"
           self.define_method :new do
             _schema, @_is_show_schema_list = ::Brick.set_db_schema(params)
-            new_params = model.attribute_names.each_with_object({}) do |a, s|
+            new_params = begin
+                           send(params_name_sym)
+                         rescue
+                         end
+            new_params ||= model.attribute_names.each_with_object({}) do |a, s|
               if (val = params["__#{a}"])
                 # val = case new_obj.class.column_for_attribute(a).type
                 #       when :datetime, :date, :time, :timestamp
@@ -2385,8 +2447,6 @@ class Object
             add_csp_hash
           end
 
-          params_name_sym = (params_name = "#{singular_table_name}_params").to_sym
-
           code << "  def create\n"
           code << "    @#{singular_table_name} = #{model.name}.create(#{params_name})\n"
           code << "  end\n"
@@ -2403,8 +2463,7 @@ class Object
               end
               render json: { result: ::Brick.unexclude_column(table_name, col) }
             else
-              @_lookup_context.instance_variable_set("@#{singular_table_name}".to_sym,
-                                                     (created_obj = model.send(:create, send(params_name_sym))))
+              created_obj = model.send(:create, send(params_name_sym))
               @_lookup_context.instance_variable_set(:@_brick_model, model)
               if created_obj.errors.empty?
                 index
@@ -2481,7 +2540,16 @@ class Object
               if (upd_hash ||= upd_params).fetch(model.inheritance_column, nil)&.strip == ''
                 upd_hash[model.inheritance_column] = nil
               end
-              obj.send(:update, upd_hash || upd_params)
+              # Do not clear out a has_many_attached field if it already has an entry and nothing is supplied
+              hoa, hma, rtans = model._activestorage_actiontext_fields
+              all_params = params[singular_table_name]
+              hma.each do |hma_field|
+                if upd_hash.fetch(hma_field) == [''] && # No new attachments...
+                   all_params&.fetch("_brick_attached_#{hma_field}", nil) # ...and there is something existing
+                  upd_hash.delete(hma_field)
+                end
+              end
+              obj.send(:update, upd_hash)
               if obj.errors.any? # Surface errors to the user in a flash message
                 flash.now.alert = (obj.errors.errors.map { |err| "<b>#{err.attribute}</b> #{err.message}" }.join(', '))
               end
@@ -2531,7 +2599,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields)
+            permits_txt = model._brick_find_permits(model, permits = model._brick_all_fields(true))
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.map(&:inspect).join(', ')})\n"
             code << "  end\n"

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

@@ -641,6 +641,11 @@ window.addEventListener(\"popstate\", linkSchemas);
                 type_col = hm_assoc.inverse_of&.foreign_type || hm_assoc.type
                 keys << [type_col, poly_type]
               end
+              # ActiveStorage has_one_attached and has_many_attached needs additional filtering on the name
+              if (as_name = hm_assoc.klass&._active_storage_name(hm_assoc.name)) # ActiveStorage HMT
+                prefix = 'attachments.' if hm_assoc.through_reflection&.klass&.<= ActiveStorage::Attachment
+                keys << ["#{prefix}name", as_name]
+              end
               keys.to_h
             end
 
@@ -1506,7 +1511,7 @@ end
 
     if (pk = hm.first.klass.primary_key)
       hm_singular_name = (hm_name = hm.first.name.to_s).singularize.underscore
-      obj_br_pk = (pk.is_a?(Array) ? pk : [pk]).each_with_object([]) { |pk_part, s| s << "br_#{hm_singular_name}.#{pk_part}" }.join(', ')
+      obj_br_pk = hm.first.klass._pk_as_array.map { |pk_part| "br_#{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

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

@@ -110,6 +110,41 @@ module Brick::Rails::FormBuilder
                    ::Brick::Rails.display_binary(val)
                  end
         end
+      when :file, :files
+        if attached = begin
+                        self.object.send(method)
+                      rescue
+                      end
+          # Show any existing image(s)
+          existing = []
+          got_one = nil
+          (attached.respond_to?(:attachments) ? attached.attachments : [attached]).each do |attachment|
+            next unless (blob = attachment.blob)
+
+            existing << blob.key
+            out << "#{blob.filename}<br>"
+            url = begin
+                    self.object.send(method)&.url
+                  rescue StandardError => e
+                    # Another possible option:
+                    # Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+                    Rails.application.routes.url_helpers.rails_storage_proxy_path(attachment, only_path: true)
+                  end
+            out << if url
+                     "<img src=\"#{url}\" title=\"#{val}\">"
+                   else # Convert the raw binary to a Base64 image
+                     ::Brick::Rails.display_binary(attachment.download, 500_000)
+                   end
+            got_one = true
+            out << '<br>'
+          end
+          out << 'Update: ' if got_one
+        end
+        out << self.hidden_field("_brick_attached_#{method}", value: existing.join(',')) unless existing.blank?
+        # Render a "Choose File(s)" input element
+        args = [method.to_sym]
+        args << { multiple: true } if col&.type == :files
+        out << self.file_field(*args)
       when :primary_key
         is_revert = false
       when :json, :jsonb

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

@@ -445,19 +445,25 @@ function onImagesLoaded(event) {
           obj.send("#{model.brick_foreign_type(v.first)}=", v[1].first&.first&.name)
         end
       end if obj.new_record?
-      rtans = model.rich_text_association_names if model.respond_to?(:rich_text_association_names)
-      (model.column_names + (rtans || [])).each do |k|
+      hoa, hma, rtans = model._activestorage_actiontext_fields
+      (model.column_names + hoa + hma + rtans.keys).each do |k|
         pk_pos = (pk.index(k)&.+ 1)
         next if (pk_pos && pk.length == 1 && !bts.key?(k)) ||
                 ::Brick.config.metadata_columns.include?(k)
 
         col = model.columns_hash[k]
-        if !col && rtans&.include?(k)
-          k = k[10..-1] if k.start_with?('rich_text_')
-          col = (rt_col ||= ActiveRecord::ConnectionAdapters::Column.new(
-                              '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: 'varchar', type: :text)
-                            )
-                )
+        if !col
+          kwargs = if hoa.include?(k) # has_one_attached
+                     { sql_type: 'binary', type: :file }
+                   elsif hma.include?(k) # has_many_attached
+                     { sql_type: 'binary', type: :files }
+                   elsif rtans&.key?(k) # has_rich_text
+                    k = rtans[k]
+                    { sql_type: 'varchar', type: :text }
+                   end
+          col = (ActiveRecord::ConnectionAdapters::Column.new(
+                  '', nil, ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(**kwargs)
+                )) if kwargs
         end
         val = obj.attributes[k]
         out << "

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 209
+    TINY = 211
 
     # 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.209
+  version: 1.0.211
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-20 00:00:00.000000000 Z
+date: 2024-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -285,7 +285,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Create a Rails app from data alone