rest_framework 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 237449a323a14356f20e47cd2cbab3591aa749fc7e6f43bc06587995ff1041dc
-  data.tar.gz: 98ff07d840fca2fd09ab608a08a2814c5fe17c9ded1a7476c176941224c75e53
+  metadata.gz: a4a0533297190fd34ec007578f495d67ef19e3e02b7b495b8be004dd2180f6b2
+  data.tar.gz: 07f5478177e47bae6476c42587b10b698a862bbcfa762497a7bd11ebb5cf324e
 SHA512:
-  metadata.gz: 5219df61d409aeda527a61508694cf5b46dba856f03db4d7a2432d8d208a89eb5ccaccee2d7da88472d5b2735a77b235127d903497b9bb3fb19b740f2eb5df05
-  data.tar.gz: afbc3a40c39d312a0ebaaade7ce8c1d4d00b99fbd3da4168b0e9706d63d2fb59aa6d0f1d56cc4832a6eca10b783f43c20a2f9cf8d1015ef817293ba5852a7a62
+  metadata.gz: d971192a3c797b69e9e7982f2f7e381b7fa2784db39e592c56f3640683985424e40a52e28a0ff503f0c22ad2b0cedbd828ba5b4461e354abe36d5d9e8c01c370
+  data.tar.gz: 22f0d3779328a0c5dccb382674d44dfea4a5cffea92b96614366d9cbfa570ce436ea5774c13a16f524b995c54074d5ad5d979e82d081d2f012f89923f55339f6

data/VERSION

@@ -1 +1 @@
-0.5.5
+0.5.6

data/lib/rest_framework/serializers.rb

@@ -1,24 +1,39 @@
 # The base serializer defines the interface for all REST Framework serializers.
 class RESTFramework::BaseSerializer
+  # Add `object` accessor to be compatible with `ActiveModel::Serializer`.
   attr_accessor :object
 
-  def initialize(object=nil, controller: nil, **kwargs)
+  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
+  def initialize(object=nil, *args, controller: nil, **kwargs)
     @object = object
     @controller = controller
   end
 
   # The primary interface for extracting a native Ruby types. This works both for records and
-  # collections.
-  def serialize(**kwargs)
+  # collections. We accept and ignore `*args` for compatibility with `active_model_serializers`.
+  def serialize(*args)
     raise NotImplementedError
   end
 
-  # :nocov:
-  # Synonym for `serializable_hash` or compatibility with ActiveModelSerializers.
-  def serializable_hash(**kwargs)
-    return self.serialize(**kwargs)
+  # Synonym for `serialize` for compatibility with `active_model_serializers`.
+  def serializable_hash(*args)
+    return self.serialize(*args)
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def self.cache_enabled?
+    return false
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def self.fragment_cache_enabled?
+    return false
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def associations(*args, **kwargs)
+    return []
   end
-  # :nocov:
 end
 
 # This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
@@ -29,8 +44,9 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   class_attribute :plural_config
   class_attribute :action_config
 
-  def initialize(object=nil, many: nil, model: nil, **kwargs)
-    super(object, **kwargs)
+  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
+  def initialize(object=nil, *args, many: nil, model: nil, **kwargs)
+    super(object, *args, **kwargs)
 
     if many.nil?
       # Determine if we are dealing with many objects or just one.
@@ -148,10 +164,7 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
       except = except.split(",").map(&:strip).map(&:to_sym)
 
       unless except.empty?
-        # Duplicate the cfg to avoid mutating class state.
-        cfg = cfg.deep_dup
-
-        # Filter `only`, `except` (additive), `include`, and `methods`.
+        # Filter `only`, `except` (additive), `include`, `methods`, and `serializer_methods`.
         if cfg[:only]
           cfg[:only] = self.class.filter_subcfg(cfg[:only], except: except)
         else
@@ -159,14 +172,14 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
         end
         cfg[:include] = self.class.filter_subcfg(cfg[:include], except: except)
         cfg[:methods] = self.class.filter_subcfg(cfg[:methods], except: except)
+        cfg[:serializer_methods] = self.class.filter_subcfg(
+          cfg[:serializer_methods], except: except
+        )
       end
     elsif only_param && only = @controller.request.query_parameters[only_param].presence
       only = only.split(",").map(&:strip).map(&:to_sym)
 
       unless only.empty?
-        # Duplicate the cfg to avoid mutating class state.
-        cfg = cfg.deep_dup
-
         # For the `except` part of the serializer, we need to append any columns not in `only`.
         model = @controller.get_model
         except_cols = model&.column_names&.map(&:to_sym)&.reject { |c| c.in?(only) }
@@ -179,27 +192,31 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
         end
         cfg[:include] = self.class.filter_subcfg(cfg[:include], only: only)
         cfg[:methods] = self.class.filter_subcfg(cfg[:methods], only: only)
+        cfg[:serializer_methods] = self.class.filter_subcfg(cfg[:serializer_methods], only: only)
       end
     end
 
     return cfg
   end
 
-  # Get the raw serializer config.
+  # Get the raw serializer config. Use `deep_dup` on any class mutables (array, hash, etc) to avoid
+  # mutating class state.
   def _get_raw_serializer_config
     # Return a locally defined serializer config if one is defined.
     if local_config = self.get_local_native_serializer_config
-      return local_config
+      return local_config.deep_dup
     end
 
     # Return a serializer config if one is defined on the controller.
     if serializer_config = self.get_controller_native_serializer_config
-      return serializer_config
+      return serializer_config.deep_dup
     end
 
     # If the config wasn't determined, build a serializer config from model fields.
     fields = @controller.get_fields if @controller
     if fields
+      fields = fields.deep_dup
+
       if @model
         columns, methods = fields.partition { |f| f.in?(@model.column_names) }
       else
@@ -216,15 +233,31 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
 
   # Get a configuration passable to `serializable_hash` for the object, filtered if required.
   def get_serializer_config
-    return @_serializer_config ||= filter_except(self._get_raw_serializer_config)
+    return filter_except(self._get_raw_serializer_config)
+  end
+
+  # Internal helper to serialize a single record and merge results of `serializer_methods`.
+  def _serialize(record, config, serializer_methods)
+    # Ensure serializer_methods is either falsy, or an array.
+    if serializer_methods && !serializer_methods.respond_to?(:to_ary)
+      serializer_methods = [serializer_methods]
+    end
+
+    # Merge serialized record with any serializer method results.
+    return record.serializable_hash(config).merge(
+      serializer_methods&.map { |m| [m.to_sym, self.send(m, record)] }.to_h,
+    )
   end
 
-  def serialize(**kwargs)
+  def serialize(*args)
+    config = self.get_serializer_config
+    serializer_methods = config.delete(:serializer_methods)
+
     if @object.respond_to?(:to_ary)
-      return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
+      return @object.map { |r| self._serialize(r, config, serializer_methods) }
     end
 
-    return @object.serializable_hash(self.get_serializer_config)
+    return self._serialize(@object, config, serializer_methods)
   end
 
   # Allow a serializer instance to be used as a hash directly in a nested serializer config.

data/lib/rest_framework/utils.rb

@@ -49,7 +49,7 @@ module RESTFramework::Utils
 
   # Helper to normalize a path pattern by replacing URL params with generic placeholder, and
   # removing the `(.:format)` at the end.
-  def self.normalize_path(path)
+  def self.comparable_path(path)
     return path.gsub("(.:format)", "").gsub(/:[0-9A-Za-z_-]+/, ":x")
   end
 
@@ -58,7 +58,7 @@ module RESTFramework::Utils
     current_route ||= self.get_request_route(application_routes, request)
     current_path = current_route.path.spec.to_s
     current_levels = current_path.count("/")
-    current_normalized_path = self.normalize_path(current_path)
+    current_comparable_path = self.comparable_path(current_path)
 
     # Return routes that match our current route subdomain/pattern, grouped by controller. We
     # precompute certain properties of the route for performance.
@@ -77,8 +77,9 @@ module RESTFramework::Utils
         route: r,
         verb: r.verb,
         path: path,
-        normalized_path: self.normalize_path(path),
-        relative_path: path.split("/")[current_levels..]&.join("/"),
+        comparable_path: self.comparable_path(path),
+        # Starts at the number of levels in current path, and removes the `(.:format)` at the end.
+        relative_path: path.split("/")[current_levels..]&.join("/")&.gsub("(.:format)", ""),
         controller: r.defaults[:controller].presence,
         action: r.defaults[:action].presence,
         subdomain: r.defaults[:subdomain].presence,
@@ -88,7 +89,7 @@ module RESTFramework::Utils
     }.select { |r|
       (
         (!r[:subdomain] || r[:subdomain] == request.subdomain.presence) &&
-        r[:normalized_path].start_with?(current_normalized_path) &&
+        r[:comparable_path].start_with?(current_comparable_path) &&
         r[:controller] &&
         r[:action]
       )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-15 00:00:00.000000000 Z
+date: 2022-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails