rest_framework 0.9.16 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59084182eeedcec7d3f1a1a913a99e55a6139bb394e4c712744c5d80778db800
-  data.tar.gz: 552ea8a39833dc6a3ec4c689f120ba549af0db49a3fafa29d63cd4cb17d85a85
+  metadata.gz: 8a916afbf32cf43553b8aa952024011639f311ab80db53685163e607e48e1ad0
+  data.tar.gz: 1cc8aa7aed712a63b1ef9586c37b64a87de62fe5dfdcf659e982a1b77c20fd89
 SHA512:
-  metadata.gz: cffd1cde2cbf956d46344018c137b723397118f3aa4ea16c2d9abf5c9d9694c8a78d8f706f96e28c637ec4f58d692553da372a832a0bd44cc58154134b733d33
-  data.tar.gz: 1eea97e45fc0f4c47edbdb04a8de05fe6e383e259ea1d3ff48196b6601aeb87341aa6750f8eb4411dd0e16934452c5a02b2d26877a9ec8382ae538312f305603
+  metadata.gz: bef1f7c3c52c7a42e8c307ccaf37e4e25f4e663359e26be433f20fd644fca0e59cd3b56613f965b084662046577576728981a320d1d5a5a6517d98556008fc99
+  data.tar.gz: '080f96e20b330a391b896db89a192e415328aa320f8d669260d8d282c0eee709022afa7fa5dd484449eb5bba85544f8974d24764a5e5b45821803d1ccd3c23f0'

data/VERSION

@@ -1 +1 @@
-0.9.16
+0.10.0

data/lib/rest_framework/mixins/base_controller_mixin.rb

@@ -17,6 +17,10 @@ module RESTFramework::Mixins::BaseControllerMixin
     serializer_class: nil,
     serialize_to_json: true,
     serialize_to_xml: true,
+
+    # Custom integrations (reduces serializer performance due to method calls).
+    enable_action_text: false,
+    enable_active_storage: false,
   }
   RRF_BASE_INSTANCE_CONFIG = {
     # Options related to pagination.

data/lib/rest_framework/mixins/model_controller_mixin.rb

@@ -103,13 +103,20 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       # If fields is a hash, then parse it.
       if input_fields.is_a?(Hash)
         return RESTFramework::Utils.parse_fields_hash(
-          input_fields, self.get_model, exclude_associations: self.exclude_associations
+          input_fields,
+          self.get_model,
+          exclude_associations: self.exclude_associations,
+          action_text: self.enable_action_text,
+          active_storage: self.enable_active_storage,
         )
       elsif !input_fields
         # Otherwise, if fields is nil, then fallback to columns.
         model = self.get_model
         return model ? RESTFramework::Utils.fields_for(
-          model, exclude_associations: self.exclude_associations
+          model,
+          exclude_associations: self.exclude_associations,
+          action_text: self.enable_action_text,
+          active_storage: self.enable_active_storage,
         ) : []
       elsif input_fields
         input_fields = input_fields.map(&:to_s)
@@ -418,21 +425,21 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     @_get_allowed_parameters = self.get_fields.map { |f|
       f = f.to_s
 
-      # ActiveStorage Integration: `has_one_attached`.
-      if reflections.key?("#{f}_attachment")
-        hash_variations[f] = ACTIVESTORAGE_KEYS
+      # ActionText Integration:
+      if self.class.enable_action_text && reflections.key?("rich_test_#{f}")
         next f
       end
 
-      # ActiveStorage Integration: `has_many_attached`.
-      if reflections.key?("#{f}_attachments")
+      # ActiveStorage Integration: `has_one_attached`
+      if self.class.enable_active_storage && reflections.key?("#{f}_attachment")
         hash_variations[f] = ACTIVESTORAGE_KEYS
-        next nil
+        next f
       end
 
-      # ActionText Integration.
-      if reflections.key?("rich_test_#{f}")
-        next f
+      # ActiveStorage Integration: `has_many_attached`
+      if self.class.enable_active_storage && reflections.key?("#{f}_attachments")
+        hash_variations[f] = ACTIVESTORAGE_KEYS
+        next nil
       end
 
       # Return field if it's not an association.
@@ -513,31 +520,33 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     #
     # rubocop:enable Layout/LineLength
     has_many_attached_scalar_data = {}
-    self.class.get_model.attachment_reflections.keys.each do |k|
-      if data[k].is_a?(Array)
-        data[k] = data[k].map { |v|
-          if v.is_a?(String)
-            v = BASE64_TRANSLATE.call(k, v)
-
-            # Remember scalars because Rails strong params will remove it.
+    if self.class.enable_active_storage
+      self.class.get_model.attachment_reflections.keys.each do |k|
+        if data[k].is_a?(Array)
+          data[k] = data[k].map { |v|
             if v.is_a?(String)
-              has_many_attached_scalar_data[k] ||= []
-              has_many_attached_scalar_data[k] << v
-            end
-          elsif v.is_a?(Hash)
-            if v[:io].is_a?(String)
-              v[:io] = StringIO.new(Base64.decode64(v[:io]))
+              v = BASE64_TRANSLATE.call(k, v)
+
+              # Remember scalars because Rails strong params will remove it.
+              if v.is_a?(String)
+                has_many_attached_scalar_data[k] ||= []
+                has_many_attached_scalar_data[k] << v
+              end
+            elsif v.is_a?(Hash)
+              if v[:io].is_a?(String)
+                v[:io] = StringIO.new(Base64.decode64(v[:io]))
+              end
             end
-          end
 
-          next v
-        }
-      elsif data[k].is_a?(Hash)
-        if data[k][:io].is_a?(String)
-          data[k][:io] = StringIO.new(Base64.decode64(data[k][:io]))
+            next v
+          }
+        elsif data[k].is_a?(Hash)
+          if data[k][:io].is_a?(String)
+            data[k][:io] = StringIO.new(Base64.decode64(data[k][:io]))
+          end
+        elsif data[k].is_a?(String)
+          data[k] = BASE64_TRANSLATE.call(k, data[k])
         end
-      elsif data[k].is_a?(String)
-        data[k] = BASE64_TRANSLATE.call(k, data[k])
       end
     end
 

data/lib/rest_framework/serializers/native_serializer.rb

@@ -246,28 +246,38 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
           includes[f] = sub_config
           includes_map[f] = f.to_sym
         end
-      elsif ref = reflections["rich_text_#{f}"]
+      elsif @controller.class.enable_action_text && ref = reflections["rich_text_#{f}"]
         # ActionText Integration: Define rich text serializer method.
         includes_map[f] = :"rich_text_#{f}"
         serializer_methods[f] = f
         self.define_singleton_method(f) do |record|
           next record.send(f).to_s
         end
-      elsif ref = attachment_reflections[f]
+      elsif @controller.class.enable_active_storage && ref = attachment_reflections[f]
         # ActiveStorage Integration: Define attachment serializer method.
         if ref.macro == :has_one_attached
           serializer_methods[f] = f
           includes_map[f] = {"#{f}_attachment": :blob}
           self.define_singleton_method(f) do |record|
             attached = record.send(f)
-            next attached.attachment ? {signed_id: attached.signed_id, url: attached.url} : nil
+            next attached.attachment ? {
+              filename: attached.filename,
+              signed_id: attached.signed_id,
+              url: attached.url,
+            } : nil
           end
         elsif ref.macro == :has_many_attached
           serializer_methods[f] = f
           includes_map[f] = {"#{f}_attachments": :blob}
           self.define_singleton_method(f) do |record|
             # Iterating the collection yields attachment objects.
-            next record.send(f).map { |a| {signed_id: a.signed_id, url: a.url} }
+            next record.send(f).map { |a|
+              {
+                filename: a.filename,
+                signed_id: a.signed_id,
+                url: a.url,
+              }
+            }
           end
         end
       elsif @model.method_defined?(f)

data/lib/rest_framework/utils.rb

@@ -153,16 +153,21 @@ module RESTFramework::Utils
   end
 
   # Parse fields hashes.
-  def self.parse_fields_hash(fields_hash, model, exclude_associations: nil)
-    parsed_fields = fields_hash[:only] || (
-      model ? self.fields_for(model, exclude_associations: exclude_associations) : []
+  def self.parse_fields_hash(h, model, exclude_associations:, action_text:, active_storage:)
+    parsed_fields = h[:only] || (
+      model ? self.fields_for(
+        model,
+        exclude_associations: exclude_associations,
+        action_text: action_text,
+        active_storage: active_storage,
+      ) : []
     )
-    parsed_fields += fields_hash[:include].map(&:to_s) if fields_hash[:include]
-    parsed_fields -= fields_hash[:exclude].map(&:to_s) if fields_hash[:exclude]
-    parsed_fields -= fields_hash[:except].map(&:to_s) if fields_hash[:except]
+    parsed_fields += h[:include].map(&:to_s) if h[:include]
+    parsed_fields -= h[:exclude].map(&:to_s) if h[:exclude]
+    parsed_fields -= h[:except].map(&:to_s) if h[:except]
 
     # Warn for any unknown keys.
-    (fields_hash.keys - [:only, :except, :include, :exclude]).each do |k|
+    (h.keys - [:only, :except, :include, :exclude]).each do |k|
       Rails.logger.warn("RRF: Unknown key in fields hash: #{k}")
     end
 
@@ -173,16 +178,24 @@ module RESTFramework::Utils
   # Get the fields for a given model, including not just columns (which includes
   # foreign keys), but also associations. Note that we always return an array of
   # strings, not symbols.
-  def self.fields_for(model, exclude_associations: nil)
+  def self.fields_for(model, exclude_associations:, action_text:, active_storage:)
     foreign_keys = model.reflect_on_all_associations(:belongs_to).map(&:foreign_key)
     base_fields = model.column_names.reject { |c| c.in?(foreign_keys) }
 
     return base_fields if exclude_associations
 
-    # Add associations in addition to normal columns.
-    return base_fields + model.reflections.map { |association, ref|
+    # ActionText Integration: Determine the normalized field names for action text attributes.
+    atf = action_text ? model.reflect_on_all_associations(:has_one).collect(&:name).select { |n|
+      n.to_s.start_with?("rich_text_")
+    }.map { |n| n.to_s.delete_prefix("rich_text_") } : []
+
+    # ActiveStorage Integration: Determine the normalized field names for active storage attributes.
+    asf = active_storage ? model.attachment_reflections.keys : []
+
+    # Associations:
+    associations = model.reflections.map { |association, ref|
       # Ignore associations for which we have custom integrations.
-      if ref.class_name.in?(%w(ActiveStorage::Attachment ActiveStorage::Blob ActionText::RichText))
+      if ref.class_name.in?(%w(ActionText::RichText ActiveStorage::Attachment ActiveStorage::Blob))
         next nil
       end
 
@@ -193,11 +206,9 @@ module RESTFramework::Utils
       end
 
       next association
-    }.compact + model.reflect_on_all_associations(:has_one).collect(&:name).select { |n|
-      n.to_s.start_with?("rich_text_")
-    }.map { |n|
-      n.to_s.delete_prefix("rich_text_")
-    } + model.attachment_reflections.keys
+    }.compact
+
+    return base_fields + associations + atf + asf
   end
 
   # Get the sub-fields that may be serialized and filtered/ordered for a reflection.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.9.16
+  version: 0.10.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-21 00:00:00.000000000 Z
+date: 2024-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails