brick 1.0.148 → 1.0.150

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66301eacecd8c8f5dc5587f234ce373673a9d8544dad12e6ae27e0b1a99bed40
-  data.tar.gz: 226f44c9814fe1b47db39be49a3c35f499dd8795197523f74e8072de641d4cdd
+  metadata.gz: 7914cc56d8cd8919835028d5ad9b05a50a2b17baf32c9699d1f78bbaf9417e0d
+  data.tar.gz: a7f945e136fe8401c54e8fd24a4d92a5cef24b22bb68d2caceac28d809ff8f07
 SHA512:
-  metadata.gz: ab20a8565d71699db3bb960dc82e8091072be169011f62beb505527e5946f406fde89dab610d26717d3be118fab0ee7daf38c774c6f0a92f9d655f54cba3d0d5
-  data.tar.gz: 2b2f29c67712b001bfe43a03b881eec48eee7cf73686fe54da8e4aa30e88af91f7b23f67e95620eccde2b171a44f4e117d0326451c5917c4ef699b6141344382
+  metadata.gz: fa3ed344e3d4beed83cf9a6fd7059d78032497f8a6c51c825fd50d163e61bd8029afe3dd82e055631d8258b0c9cf54f7d176e064c47fe9fb5a70cc25cdb67faf
+  data.tar.gz: e43ca92a155c805d4dc5be0a2548d9612bc0b1a92cb2e65722ca4c55c81dbef9b476493d6764eece75489e9caf60e2a1046ca960d9a58cafe060aeae11db954a

data/lib/brick/extensions.rb

@@ -95,7 +95,7 @@ module ActiveRecord
       return @_brick_primary_key if instance_variable_defined?(:@_brick_primary_key)
 
       pk = begin
-             primary_key.is_a?(String) ? [primary_key] : primary_key || []
+             primary_key.is_a?(String) ? [primary_key] : primary_key.dup || []
            rescue
              []
            end
@@ -907,7 +907,7 @@ JOIN (SELECT #{hm_selects.map { |s| _br_quoted_name("#{'br_t0.' if from_clause}#
               s << v
             end
           else # String stuff (which defines a custom ORDER BY) just comes straight through
-            v = v.split('.').map { |x| _br_quoted_name(x) }.join('.')
+            # v = v.split('.').map { |x| _br_quoted_name(x) }.join('.')
             s << v
             # Avoid "PG::InvalidColumnReference: ERROR: for SELECT DISTINCT, ORDER BY expressions must appear in select list" in Postgres
             selects << v if is_distinct
@@ -1695,7 +1695,7 @@ class Object
       when Symbol
         order_tbl[order_default] || order_default
       else
-        pk.map { |part| "#{table_name}.#{part}"}.join(', ') # If it's not a custom ORDER BY, just use the key
+        pk.map { |part| "#{table_name}.#{part}"} # If it's not a custom ORDER BY, just use the key
       end
     end
 
@@ -2238,12 +2238,7 @@ class Object
 
           if is_need_params
             code << "  def #{params_name}\n"
-            permits = model.columns_hash.keys.map(&:to_sym)
-            permits_txt = permits.map(&:inspect) +
-                          model.reflect_on_all_associations.select { |assoc| assoc.macro == :has_many && assoc.options[:through] }.map do |assoc|
-                            permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
-                            "#{assoc.name.to_s.singularize}_ids: []"
-                          end
+            permits_txt = self._brick_find_permits(model, (permits = model.columns_hash.keys.map(&:to_sym)))
             code << "    params.require(:#{require_name = model.name.underscore.tr('/', '_')
                              }).permit(#{permits_txt.join(', ')})\n"
             code << "  end\n"
@@ -2259,6 +2254,98 @@ class Object
       [built_controller, code]
     end
 
+    def _brick_find_permits(model, current_permits)
+      model.reflect_on_all_associations.select { |assoc| assoc.macro == :has_many }.each_with_object([]) do |assoc, s|
+        if assoc.options[:through]
+          current_permits << { "#{assoc.name.to_s.singularize}_ids".to_sym => [] }
+          s << "#{assoc.name.to_s.singularize}_ids: []"
+        elsif assoc.active_record.instance_methods.include?(:"#{assoc.name}_attributes=")
+          # Support nested attributes which use the friendly_id gem
+          self._brick_nested_friendly_id if Object.const_defined?('FriendlyId') &&
+                                            assoc.klass.instance_variable_get(:@friendly_id_config)
+          new_attrib_text = self._brick_find_permits(assoc.klass, (new_permits = assoc.klass.columns_hash.keys.map(&:to_sym)))
+          new_permits << :_destroy
+          current_permits << { "#{assoc.name}_attributes".to_sym => new_permits }
+          s << "#{assoc.name}_attributes: #{new_attrib_text}"
+        end
+      end
+      current_permits
+    end
+
+    def _brick_nested_friendly_id
+      unless @_brick_nested_friendly_id
+        ::ActiveRecord::Base.class_exec do
+          if private_instance_methods.include?(:assign_nested_attributes_for_collection_association)
+            alias _brick_anafca assign_nested_attributes_for_collection_association
+            def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+              association = association(association_name)
+              slug_column = association.klass.instance_variable_get(:@friendly_id_config)&.slug_column
+              return _brick_anafca unless slug_column
+
+              # Here is the FriendlyId version of #assign_nested_attributes_for_collection_association
+              options = nested_attributes_options[association_name]
+              attributes_collection = attributes_collection.to_h if attributes_collection.respond_to?(:permitted?)
+
+              unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+                raise ArgumentError, "Hash or Array expected for attribute `#{association_name}`, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+              end
+
+              check_record_limit!(options[:limit], attributes_collection)
+
+              if attributes_collection.is_a? Hash
+                keys = attributes_collection.keys
+                attributes_collection = if keys.include?("id") || keys.include?(:id)
+                                          [attributes_collection]
+                                        else
+                                          attributes_collection.values
+                                        end
+              end
+              existing_records = if association.loaded?
+                                   association.target
+                                 else
+                                   attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
+                                   if attribute_ids.empty?
+                                     []
+                                   else # Implement the same logic as "friendly" scope
+                                     association.scope.where(association.klass.primary_key => attribute_ids)
+                                                      .or(association.scope.where(slug_column => attribute_ids))
+                                   end
+                                 end
+              attributes_collection.each do |attributes|
+                attributes = attributes.to_h if attributes.respond_to?(:permitted?)
+                attributes = attributes.with_indifferent_access
+                if attributes["id"].blank? && attributes[slug_column].blank?
+                  unless reject_new_record?(association_name, attributes)
+                    association.reader.build(attributes.except(*::ActiveRecord::Base::UNASSIGNABLE_KEYS))
+                  end
+                elsif (attr_id_str = attributes["id"].to_s) && 
+                      (existing_record = existing_records.detect { |record| record.id.to_s == attr_id_str ||
+                                                                            record.send(slug_column).to_s == attr_id_str })
+                  unless call_reject_if(association_name, attributes)
+                    # Make sure we are operating on the actual object which is in the association's
+                    # proxy_target array (either by finding it, or adding it if not found)
+                    # Take into account that the proxy_target may have changed due to callbacks
+                    target_record = association.target.detect { |record| record.id.to_s == attr_id_str ||
+                                                                          record.send(slug_column).to_s == attr_id_str }
+                    if target_record
+                      existing_record = target_record
+                    else
+                      association.add_to_target(existing_record, skip_callbacks: true)
+                    end
+
+                    assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+                  end
+                else
+                  raise_nested_attributes_record_not_found!(association_name, attributes["id"])
+                end
+              end
+            end # anafca
+          end
+        end if ::ActiveRecord::QueryMethods.instance_methods.include?(:or)
+        @_brick_nested_friendly_id = true
+      end
+    end
+
     def _brick_get_hm_assoc_name(relation, hm_assoc, source = nil)
       assoc_name, needs_class = if (relation[:hm_counts][hm_assoc[:inverse_table]]&.> 1) &&
                                    hm_assoc[:alternate_name] != (source || name.underscore)

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

@@ -46,12 +46,12 @@ module Brick
               end
             end
             unless val_err || val.nil?
-              if (geometry = RGeo::WKRep::WKBParser.new.parse(val.pack('c*'))).is_a?(RGeo::Cartesian::PointImpl) &&
-                 !(geometry.y == 0.0 && geometry.x == 0.0)
-                # Create a POINT link to this style of Google maps URL:  https://www.google.com/maps/place/38.7071296+-121.2810649/@38.7071296,-121.2810649,12z
-                geometry = "<a href=\"https://www.google.com/maps/place/#{geometry.y}+#{geometry.x}/@#{geometry.y},#{geometry.x},12z\" target=\"blank\">#{geometry.to_s}</a>"
-              end
-              val = geometry
+              val = if ((geometry = RGeo::WKRep::WKBParser.new.parse(val.pack('c*'))).is_a?(RGeo::Cartesian::PointImpl) ||
+                        geometry.is_a?(RGeo::Geos::CAPIPointImpl)) &&
+                       !(geometry.y == 0.0 && geometry.x == 0.0)
+                      # Create a POINT link to this style of Google maps URL:  https://www.google.com/maps/place/38.7071296+-121.2810649/@38.7071296,-121.2810649,12z
+                      "<a href=\"https://www.google.com/maps/place/#{geometry.y}+#{geometry.x}/@#{geometry.y},#{geometry.x},12z\" target=\"blank\">#{geometry.to_s}</a>"
+                    end
             end
             val_err || val
           else
@@ -1760,14 +1760,17 @@ end
           <tr><td<%= ' class=\"orphan\"'.html_safe if err_msg %>><%= err_msg || '(none)' %></td></tr>
      <% else
           collection2.each do |br_#{hm_singular_name}| %>
-            <tr><td><%= br_descrip = if br_#{hm_singular_name}.respond_to?(descrip_cols&.first&.first&.last)
+            <tr><td><%= br_descrip = if (dc = descrip_cols&.first&.first&.last) && br_#{hm_singular_name}.respond_to?(dc)
                                        br_#{hm_singular_name}.brick_descrip(
                                          descrip_cols&.first&.map { |col| br_#{hm_singular_name}.send(col.last) }
                                        )
                                      else # If the HM association has a scope, might not have picked up our SELECT detail
                                        pks = (klass = br_#{hm_singular_name}.class).primary_key
-                                       pks = [pks] unless pks.is_a?(Array)
-                                       pks.map! { |pk| br_#{hm_singular_name}.send(pk).to_s }
+                                       pks = if pks.is_a?(Array)
+                                               pks.map { |pk| br_#{hm_singular_name}.send(pk).to_s }
+                                             else
+                                               [br_#{hm_singular_name}.send(pks).to_s]
+                                             end
                                        \"#\{klass.name} ##\{pks.join(', ')}\"
                                      end
                         link_to(br_descrip, #{hm.first.klass._brick_index(:singular)}_path(slashify(#{obj_br_pk}))) %></td></tr>

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

@@ -104,7 +104,7 @@ module Brick::Rails::FormBuilder
         out << "<div id=\"_br_json_#{self.field_id(method)}\"></div>"
       else
         is_revert = false
-        out << ::Brick::Rails.display_value(col_type, val).html_safe
+        out << (::Brick::Rails.display_value(col_type, val)&.html_safe || '')
       end
     end
     if is_revert

data/lib/brick/version_number.rb

@@ -5,7 +5,7 @@ module Brick
   module VERSION
     MAJOR = 1
     MINOR = 0
-    TINY = 148
+    TINY = 150
 
     # 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.148
+  version: 1.0.150
 platform: ruby
 authors:
 - Lorin Thwaits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-31 00:00:00.000000000 Z
+date: 2023-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord