fast_jsonapi 1.0.17 → 1.1.0

data/lib/fast_jsonapi/object_serializer.rb

@@ -1,76 +1,60 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/object'
 require 'active_support/concern'
 require 'active_support/inflector'
-require 'oj'
-require 'multi_json'
 require 'fast_jsonapi/serialization_core'
 
-begin
-  require 'skylight'
-  SKYLIGHT_ENABLED = true
-rescue LoadError
-  SKYLIGHT_ENABLED = false
-end
-
 module FastJsonapi
   module ObjectSerializer
     extend ActiveSupport::Concern
     include SerializationCore
 
-    included do
-      # Skylight integration
-      # To remove Skylight
-      # Remove the included do block
-      # Remove the Gemfile entry
-      if SKYLIGHT_ENABLED
-        include Skylight::Helpers
-
-        instrument_method :serializable_hash
-        instrument_method :to_json
-      end
+    SERIALIZABLE_HASH_NOTIFICATION = 'render.fast_jsonapi.serializable_hash'.freeze
+    SERIALIZED_JSON_NOTIFICATION = 'render.fast_jsonapi.serialized_json'.freeze
 
+    included do
       # Set record_type based on the name of the serializer class
-      set_type default_record_type if default_record_type
+      set_type(reflected_record_type) if reflected_record_type
     end
 
     def initialize(resource, options = {})
-      if options.present?
-        @meta_tags = options[:meta]
-        @includes = options[:include].delete_if(&:blank?) if options[:include].present?
-        self.class.has_permitted_includes(@includes) if @includes.present?
-        @known_included_objects = {} # keep track of inc objects that have already been serialized
-      end
-      # @records if enumerables like Array, ActiveRecord::Relation but if Struct just make it a @record
-      if resource.respond_to?(:each) && !resource.respond_to?(:each_pair)
-        @records = resource
-      else
-        @record = resource
-      end
+      process_options(options)
+
+      @resource = resource
     end
 
     def serializable_hash
-      serializable_hash = { data: nil }
-      serializable_hash[:meta] = @meta_tags if @meta_tags.present?
-      return hash_for_one_record(serializable_hash) if @record
-      return hash_for_multiple_records(serializable_hash) if @records
-      serializable_hash
+      return hash_for_collection if is_collection?(@resource)
+
+      hash_for_one_record
     end
+    alias_method :to_hash, :serializable_hash
+
+    def hash_for_one_record
+      serializable_hash = { data: nil }
+      serializable_hash[:meta] = @meta if @meta.present?
+
+      return serializable_hash unless @resource
 
-    def hash_for_one_record(serializable_hash)
-      serializable_hash[:data] = self.class.record_hash(@record)
-      serializable_hash[:included] = self.class.get_included_records(@record, @includes, @known_included_objects) if @includes.present?
+      serializable_hash[:data] = self.class.record_hash(@resource)
+      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects) if @includes.present?
       serializable_hash
     end
 
-    def hash_for_multiple_records(serializable_hash)
+    def hash_for_collection
+      serializable_hash = {}
+
       data = []
       included = []
-      @records.each do |record|
+      @resource.each do |record|
         data << self.class.record_hash(record)
         included.concat self.class.get_included_records(record, @includes, @known_included_objects) if @includes.present?
       end
+
       serializable_hash[:data] = data
       serializable_hash[:included] = included if @includes.present?
+      serializable_hash[:meta] = @meta if @meta.present?
       serializable_hash
     end
 
@@ -78,24 +62,74 @@ module FastJsonapi
       self.class.to_json(serializable_hash)
     end
 
+    private
+
+    def process_options(options)
+      return if options.blank?
+
+      @known_included_objects = {}
+      @meta = options[:meta]
+
+      if options[:include].present?
+        @includes = options[:include].delete_if(&:blank?).map(&:to_sym)
+        validate_includes!(@includes)
+      end
+    end
+
+    def validate_includes!(includes)
+      return if includes.blank?
+
+      existing_relationships = self.class.relationships_to_serialize.keys.to_set
+
+      unless existing_relationships.superset?(includes.to_set)
+        raise ArgumentError, "One of keys from #{includes} is not specified as a relationship on the serializer"
+      end
+    end
+
+    def is_collection?(resource)
+      resource.respond_to?(:each) && !resource.respond_to?(:each_pair)
+    end
+
     class_methods do
+      def reflected_record_type
+        return @reflected_record_type if defined?(@reflected_record_type)
+
+        @reflected_record_type ||= begin
+          if self.name.end_with?('Serializer')
+            self.name.split('::').last.chomp('Serializer').underscore.to_sym
+          end
+        end
+      end
+
+      def set_key_transform(transform_name)
+        mapping = {
+          camel: :camelize,
+          camel_lower: [:camelize, :lower],
+          dash: :dasherize,
+          underscore: :underscore
+        }
+        @transform_method = mapping[transform_name.to_sym]
+      end
+
+      def run_key_transform(input)
+        if @transform_method.present?
+          input.to_s.send(*@transform_method).to_sym
+        else
+          input.to_sym
+        end
+      end
+
       def use_hyphen
-        @hyphenated = true
+        warn('DEPRECATION WARNING: use_hyphen is deprecated and will be removed from fast_jsonapi 2.0 use (set_key_transform :dash) instead')
+        set_key_transform :dash
       end
 
       def set_type(type_name)
-        self.record_type = type_name
-        if @hyphenated
-          self.record_type = type_name.to_s.dasherize.to_sym
-        end
+        self.record_type = run_key_transform(type_name)
       end
 
-      def default_record_type
-        if self.name.end_with?('Serializer')
-          class_name = self.name.demodulize
-          range_end = class_name.rindex('Serializer')
-          class_name[0...range_end].underscore.to_sym
-        end
+      def set_id(id_name)
+        self.record_id = id_name
       end
 
       def cache_options(cache_options)
@@ -103,19 +137,18 @@ module FastJsonapi
         self.cache_length = cache_options[:cache_length] || 5.minutes
       end
 
-      def attributes(*attributes_list)
+      def attributes(*attributes_list, &block)
         attributes_list = attributes_list.first if attributes_list.first.class.is_a?(Array)
         self.attributes_to_serialize = {} if self.attributes_to_serialize.nil?
         attributes_list.each do |attr_name|
           method_name = attr_name
-          key = method_name
-          if @hyphenated
-            key = attr_name.to_s.dasherize.to_sym
-          end
-          attributes_to_serialize[key] = method_name
+          key = run_key_transform(method_name)
+          attributes_to_serialize[key] = block || method_name
         end
       end
 
+      alias_method :attribute, :attributes
+
       def add_relationship(name, relationship)
         self.relationships_to_serialize = {} if relationships_to_serialize.nil?
         self.cachable_relationships_to_serialize = {} if cachable_relationships_to_serialize.nil?
@@ -130,15 +163,11 @@ module FastJsonapi
      end
 
       def has_many(relationship_name, options = {})
-        singular_name = relationship_name.to_s.singularize
-        record_type = options[:record_type] || singular_name.to_sym
         name = relationship_name.to_sym
-        key = options[:key] || name
-        if @hyphenated
-          key = options[:key] || relationship_name.to_s.dasherize.to_sym
-          record_type = options[:record_type] || singular_name.to_s.dasherize.to_sym
-        end
-        serializer_key = options[:serializer] || record_type
+        singular_name = relationship_name.to_s.singularize
+        serializer_key = options[:serializer] || singular_name.to_sym
+        key = options[:key] || run_key_transform(relationship_name)
+        record_type = options[:record_type] || run_key_transform(singular_name)
         relationship = {
           key: key,
           name: name,
@@ -147,21 +176,18 @@ module FastJsonapi
           object_method_name: options[:object_method_name] || name,
           serializer: compute_serializer_name(serializer_key),
           relationship_type: :has_many,
-          cached: options[:cached] || false
+          cached: options[:cached] || false,
+          polymorphic: fetch_polymorphic_option(options)
         }
         add_relationship(name, relationship)
       end
 
       def belongs_to(relationship_name, options = {})
         name = relationship_name.to_sym
-        key = options[:key] || name
-        record_type = options[:record_type] || name
-        serializer_key = options[:serializer] || record_type
-        if @hyphenated
-          key = options[:key] || relationship_name.to_s.dasherize.to_sym
-          record_type = options[:record_type] || relationship_name.to_s.dasherize.to_sym
-        end
-        relationship = {
+        serializer_key = options[:serializer] || relationship_name.to_sym
+        key = options[:key] || run_key_transform(relationship_name)
+        record_type = options[:record_type] || run_key_transform(relationship_name)
+        add_relationship(name, {
           key: key,
           name: name,
           id_method_name: options[:id_method_name] || (relationship_name.to_s + '_id').to_sym,
@@ -169,21 +195,17 @@ module FastJsonapi
           object_method_name: options[:object_method_name] || name,
           serializer: compute_serializer_name(serializer_key),
           relationship_type: :belongs_to,
-          cached: options[:cached] || true
-        }
-        add_relationship(name, relationship)
+          cached: options[:cached] || true,
+          polymorphic: fetch_polymorphic_option(options)
+        })
       end
 
       def has_one(relationship_name, options = {})
         name = relationship_name.to_sym
-        key = options[:key] || name
-        record_type = options[:record_type] || name
-        serializer_key = options[:serializer] || record_type
-        if @hyphenated
-          key = options[:key] || relationship_name.to_s.dasherize.to_sym
-          record_type = options[:record_type] || relationship_name.to_s.dasherize.to_sym
-        end
-        relationship = {
+        serializer_key = options[:serializer] || name
+        key = options[:key] || run_key_transform(relationship_name)
+        record_type = options[:record_type] || run_key_transform(relationship_name)
+        add_relationship(name, {
           key: key,
           name: name,
           id_method_name: options[:id_method_name] || (relationship_name.to_s + '_id').to_sym,
@@ -191,9 +213,9 @@ module FastJsonapi
           object_method_name: options[:object_method_name] || name,
           serializer: compute_serializer_name(serializer_key),
           relationship_type: :has_one,
-          cached: options[:cached] || false
-        }
-        add_relationship(name, relationship)
+          cached: options[:cached] || false,
+          polymorphic: fetch_polymorphic_option(options)
+        })
       end
 
       def compute_serializer_name(serializer_key)
@@ -202,6 +224,13 @@ module FastJsonapi
         return (namespace + serializer_name).to_sym if namespace.present?
         (serializer_key.to_s.classify + 'Serializer').to_sym
       end
+
+      def fetch_polymorphic_option(options)
+        option = options[:polymorphic]
+        return false unless option.present?
+        return option if option.respond_to? :keys
+        {}
+      end
     end
   end
 end

data/lib/fast_jsonapi/serialization_core.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
+require 'fast_jsonapi/multi_to_json'
 
 module FastJsonapi
   module SerializationCore
@@ -11,6 +14,7 @@ module FastJsonapi
                       :cachable_relationships_to_serialize,
                       :uncachable_relationships_to_serialize,
                       :record_type,
+                      :record_id,
                       :cache_length,
                       :cached
       end
@@ -26,58 +30,78 @@ module FastJsonapi
         id_hash(ids, record_type) # ids variable is just a single id here
       end
 
+      def id_hash_from_record(record, record_types)
+        # memoize the record type within the record_types dictionary, then assigning to record_type:
+        record_type = record_types[record.class] ||= record.class.name.underscore.to_sym
+        { id: record.id.to_s, type: record_type }
+      end
+
+      def ids_hash_from_record_and_relationship(record, relationship)
+        polymorphic = relationship[:polymorphic]
+
+        return ids_hash(
+          record.public_send(relationship[:id_method_name]),
+          relationship[:record_type]
+        ) unless polymorphic
+
+        object_method_name = relationship.fetch(:object_method_name, relationship[:name])
+        return unless associated_object = record.send(object_method_name)
+
+        return associated_object.map do |object|
+          id_hash_from_record object, polymorphic
+        end if associated_object.respond_to? :map
+
+        id_hash_from_record associated_object, polymorphic
+      end
+
       def attributes_hash(record)
-        attributes_hash = {}
-        attributes_to_serialize.each do |key, method_name|
-          attributes_hash[key] = record.send(method_name)
+        attributes_to_serialize.each_with_object({}) do |(key, method), attr_hash|
+          attr_hash[key] = method.is_a?(Proc) ? method.call(record) : record.public_send(method)
         end
-        attributes_hash
       end
 
       def relationships_hash(record, relationships = nil)
-        relationships_hash = {}
         relationships = relationships_to_serialize if relationships.nil?
 
-        relationships.each do |_k, relationship|
+        relationships.each_with_object({}) do |(_k, relationship), hash|
           name = relationship[:key]
-          id_method_name = relationship[:id_method_name]
-          record_type = relationship[:record_type]
           empty_case = relationship[:relationship_type] == :has_many ? [] : nil
-          relationships_hash[name] = {
-            data: ids_hash(record.send(id_method_name), record_type) || empty_case
+          hash[name] = {
+            data: ids_hash_from_record_and_relationship(record, relationship) || empty_case
           }
         end
-        relationships_hash
       end
 
       def record_hash(record)
         if cached
           record_hash = Rails.cache.fetch(record.cache_key, expires_in: cache_length) do
-            record_hash = id_hash(record.id, record_type) || { id: nil, type: record_type }
-            record_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
-            record_hash[:relationships] = {}
-            record_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize) if cachable_relationships_to_serialize.present?
-            record_hash
+            id = record_id ? record.send(record_id) : record.id
+            temp_hash = id_hash(id, record_type) || { id: nil, type: record_type }
+            temp_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
+            temp_hash[:relationships] = {}
+            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize) if cachable_relationships_to_serialize.present?
+            temp_hash
           end
           record_hash[:relationships] = record_hash[:relationships].merge(relationships_hash(record, uncachable_relationships_to_serialize)) if uncachable_relationships_to_serialize.present?
           record_hash
         else
-          record_hash = id_hash(record.id, record_type) || { id: nil, type: record_type }
+          id = record_id ? record.send(record_id) : record.id
+          record_hash = id_hash(id, record_type) || { id: nil, type: record_type }
           record_hash[:attributes] = attributes_hash(record) if attributes_to_serialize.present?
           record_hash[:relationships] = relationships_hash(record) if relationships_to_serialize.present?
           record_hash
         end
       end
 
+      # Override #to_json for alternative implementation
       def to_json(payload)
-        MultiJson.dump(payload) if payload.present?
+        FastJsonapi::MultiToJson.to_json(payload) if payload.present?
       end
 
       # includes handler
 
       def get_included_records(record, includes_list, known_included_objects)
-        included_records = []
-        includes_list.each do |item|
+        includes_list.each_with_object([]) do |item, included_records|
           object_method_name = @relationships_to_serialize[item][:object_method_name]
           record_type = @relationships_to_serialize[item][:record_type]
           serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
@@ -92,18 +116,6 @@ module FastJsonapi
             included_records << serializer.record_hash(inc_obj)
           end
         end
-        included_records
-      end
-
-      def has_permitted_includes(requested_includes)
-        # requested includes should be within relationships defined on serializer
-        allowed_includes = @relationships_to_serialize.keys
-        intersection = allowed_includes & requested_includes
-        if intersection.sort == requested_includes.sort
-          true
-        else
-          raise ArgumentError, "One of keys from #{requested_includes} is not specified as a relationship on the serializer"
-        end
       end
     end
   end

data/lib/generators/serializer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a serializer for the given model.
+
+Example:
+    rails generate serializer Movie
+
+    This will create:
+        app/serializers/movie_serializer.rb