Cache results from Serialization#lookup_serializer

This is especially helpful for serializing "has_many" associations.

Author: Nitemaeric

lib/transmutation/serialization.rb

@@ -12,27 +12,35 @@ module Serialization
     # @return [Transmutation::Serializer] The serialized object. This will respond to `#as_json` and `#to_json`.
     def serialize(object, namespace: nil, serializer: nil, depth: 0, max_depth: 1)
       if object.respond_to?(:map) && !object.respond_to?(:to_hash)
-        return object.map do |item|
-          serialize(item, namespace:, serializer:, depth:, max_depth:)
-        end
+        return object.map { |item| serialize(item, namespace:, serializer:, depth:, max_depth:) }
       end
 
-      lookup_serializer(object, namespace:, serializer:)
-        .new(object, depth:, max_depth:)
+      lookup_serializer(object, namespace:, serializer:).new(object, depth:, max_depth:)
     end
 
     # Lookup the serializer for the given object.
     #
     # This calls {Transmutation::Serialization::Lookup#serializer_for} to find the serializer for the given object.
     #
+    # This also caches the result for future lookups.
+    #
     # @param object [Object] The object to lookup the serializer for.
     # @param namespace [String, Symbol, Module] The namespace to lookup the serializer in.
     # @param serializer [String, Symbol, Class] The serializer to use.
     #
     # @return [Class<Transmutation::Serializer>] The serializer for the given object.
     #
     def lookup_serializer(object, namespace: nil, serializer: nil)
-      Lookup.new(self, namespace:).serializer_for(object, serializer:)
+      Serialization.cache[[self.namespace, object.class, namespace, serializer]] ||=
+        Lookup.new(self, namespace:).serializer_for(object, serializer:)
+    end
+
+    def self.cache
+      @cache ||= {}
+    end
+
+    def namespace
+      @namespace ||= self.class.name.split("::")[...-1].join("::")
     end
 
     private_class_method def self.included(base)

lib/transmutation/serialization/lookup.rb

@@ -18,13 +18,13 @@ def initialize(caller, namespace: nil)
       #   namespace: Api::V1::Admin::Detailed
       #   serializer: Chat::User
       #
-      #   This method will attempt to find a serializer defined in the following order:
+      #   # This method will attempt to find a serializer defined in the following order:
       #
-      #   - Api::V1::Admin::Detailed::Chat::UserSerializer
-      #   - Api::V1::Admin::Chat::UserSerializer
-      #   - Api::V1::Chat::UserSerializer
-      #   - Api::Chat::UserSerializer
-      #   - Chat::UserSerializer
+      #   # - Api::V1::Admin::Detailed::Chat::UserSerializer
+      #   # - Api::V1::Admin::Chat::UserSerializer
+      #   # - Api::V1::Chat::UserSerializer
+      #   # - Api::Chat::UserSerializer
+      #   # - Chat::UserSerializer
       def serializer_for(object, serializer: nil)
         serializer_name = serializer_name_for(object, serializer:)
 
@@ -65,14 +65,10 @@ def potential_namespaces
       end
 
       def serializer_namespace
-        return caller_namespace if @namespace.nil?
-        return @namespace       if @namespace.start_with?("::")
+        return @caller.namespace if @namespace.nil?
+        return @namespace        if @namespace.start_with?("::")
 
-        "#{caller_namespace}::#{@namespace}"
-      end
-
-      def caller_namespace
-        @caller_namespace ||= @caller.class.name.split("::")[...-1].join("::")
+        "#{@caller.namespace}::#{@namespace}"
       end
 
       def constantize_serializer!(namespace, name, object:)