Extract modules/classes to their own files.

Author: beauby

lib/active_model/serializer/adapter/json_api.rb

@@ -5,98 +5,10 @@ class JsonApi < Base
         extend ActiveSupport::Autoload
         autoload :PaginationLinks
         autoload :FragmentCache
-
-        # TODO: if we like this abstraction and other API objects to it,
-        # then extract to its own file and require it.
-        module ApiObjects
-          module JsonApi
-            ActiveModel::Serializer.config.jsonapi_version = '1.0'
-            ActiveModel::Serializer.config.jsonapi_toplevel_meta = {}
-            # Make JSON API top-level jsonapi member opt-in
-            # ref: http://jsonapi.org/format/#document-top-level
-            ActiveModel::Serializer.config.jsonapi_include_toplevel_object = false
-
-            module_function
-
-            def add!(hash)
-              hash.merge!(object) if include_object?
-            end
-
-            def include_object?
-              ActiveModel::Serializer.config.jsonapi_include_toplevel_object
-            end
-
-            # TODO: see if we can cache this
-            def object
-              object = {
-                jsonapi: {
-                  version: ActiveModel::Serializer.config.jsonapi_version,
-                  meta: ActiveModel::Serializer.config.jsonapi_toplevel_meta
-                }
-              }
-              object[:jsonapi].reject! { |_, v| v.blank? }
-
-              object
-            end
-          end
-
-          ResourceIdentifier = Struct.new(:id, :type) do
-            def self.type_for(serializer)
-              return serializer._type if serializer._type
-              if ActiveModel::Serializer.config.jsonapi_resource_type == :singular
-                serializer.object.class.model_name.singular
-              else
-                serializer.object.class.model_name.plural
-              end
-            end
-
-            def self.id_for(serializer)
-              if serializer.respond_to?(:id)
-                serializer.id
-              else
-                serializer.object.id
-              end
-            end
-
-            def self.from_serializer(serializer)
-              new(id_for(serializer), type_for(serializer))
-            end
-
-            def to_h
-              { id: id.to_s, type: type }
-            end
-          end
-
-          Resource = Struct.new(:identifier, :attributes, :relationships) do
-            def to_h
-              hash = identifier.to_h
-              hash[:attributes] = attributes if attributes.any?
-              hash[:relationships] = Hash[relationships.map { |k, v| [k, v.to_h] }] if relationships.any?
-
-              hash
-            end
-          end
-
-          class Relationship
-            # NOTE(beauby): Currently only `data` is used.
-            attr_accessor :data, :meta, :links
-
-            def initialize(hash = {})
-              hash.each { |k, v| send("#{k}=", v) }
-            end
-
-            def to_h
-              data_hash =
-                if data.is_a?(Array)
-                  data.map { |ri| ri.respond_to?(:to_h) ? ri.to_h : ri }
-                elsif data
-                  data.respond_to?(:to_h) ? data.to_h : data
-                end
-
-              { data: data_hash }
-            end
-          end
-        end
+        autoload :Resource
+        autoload :ResourceIdentifier
+        autoload :Relationship
+        require 'active_model/serializer/adapter/json_api/json_api_object'
 
         def initialize(serializer, options = {})
           super
@@ -119,7 +31,7 @@ def serializable_hash(options = nil)
 
           hash[:included] = included.map(&:to_h) if included.any?
 
-          ApiObjects::JsonApi.add!(hash)
+          JsonApiObject.add!(hash)
 
           if is_collection && serializer.paginated?
             hash[:links] ||= {}
@@ -158,7 +70,7 @@ def resource_objects_for(serializer)
         end
 
         # Recursively build all requested resource objects and flag them as primary when applicable.
-        # @return [Hash<ApiObjects::ResourceIdentifier, Hash>]
+        # @return [Hash<ResourceIdentifier, Hash>]
         #   Hash of hashes each describing a resource object and whether it is primary or included.
         #
         # @api private
@@ -170,13 +82,13 @@ def _resource_objects_for(serializer, include_tree, is_primary, hashes = {})
 
           return hashes unless serializer && serializer.object
 
-          resource_identifier = ApiObjects::ResourceIdentifier.from_serializer(serializer)
+          resource_identifier = ResourceIdentifier.from_serializer(serializer)
           if hashes[resource_identifier]
             hashes[resource_identifier][:is_primary] ||= is_primary
             return hashes
           end
 
-          resource_object = ApiObjects::Resource.new(
+          resource_object = Resource.new(
             resource_identifier,
             attributes_for(serializer),
             relationships_for(serializer))
@@ -196,7 +108,7 @@ def _resource_objects_for(serializer, include_tree, is_primary, hashes = {})
         def attributes_for(serializer)
           hash = cache_check(serializer) do
             attributes = serializer.attributes.except(:id)
-            resource_type = ApiObjects::ResourceIdentifier.type_for(serializer)
+            resource_type = ResourceIdentifier.type_for(serializer)
             requested_fields = @fieldset.fields_for(resource_type)
             attributes.slice!(*requested_fields) if requested_fields
 
@@ -214,26 +126,26 @@ def attributes_for(serializer)
         # @api private
         def linkage_for(serializer, options = {})
           if serializer.respond_to?(:each)
-            serializer.map { |s| ApiObjects::ResourceIdentifier.from_serializer(s) }
+            serializer.map { |s| ResourceIdentifier.from_serializer(s) }
           else
             if options[:virtual_value]
               options[:virtual_value]
             elsif serializer && serializer.object
-              ApiObjects::ResourceIdentifier.from_serializer(serializer)
+              ResourceIdentifier.from_serializer(serializer)
             end
           end
         end
 
         # Get resource relationships.
-        # @return [Hash<String, ApiObjects::Relationship>] relationships
+        # @return [Hash<String, Relationship>] relationships
         #
         # @api private
         def relationships_for(serializer)
-          resource_type = ApiObjects::ResourceIdentifier.type_for(serializer)
+          resource_type = ResourceIdentifier.type_for(serializer)
           requested_associations = @fieldset.fields_for(resource_type) || '*'
           include_tree = IncludeTree.from_include_args(requested_associations)
           serializer.associations(include_tree).each_with_object({}) do |association, hash|
-            hash[association.key] = ApiObjects::Relationship.new(data: linkage_for(association.serializer, association.options))
+            hash[association.key] = Relationship.new(data: linkage_for(association.serializer, association.options))
           end
         end
 

lib/active_model/serializer/adapter/json_api/json_api_object.rb

@@ -0,0 +1,38 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        module JsonApiObject
+          ActiveModel::Serializer.config.jsonapi_version = '1.0'
+          ActiveModel::Serializer.config.jsonapi_toplevel_meta = {}
+          # Make JSON API top-level jsonapi member opt-in
+          # ref: http://jsonapi.org/format/#document-top-level
+          ActiveModel::Serializer.config.jsonapi_include_toplevel_object = false
+
+          module_function
+
+          def add!(hash)
+            hash.merge!(object) if include_object?
+          end
+
+          def include_object?
+            ActiveModel::Serializer.config.jsonapi_include_toplevel_object
+          end
+
+          # TODO: see if we can cache this
+          def object
+            object = {
+              jsonapi: {
+                version: ActiveModel::Serializer.config.jsonapi_version,
+                meta: ActiveModel::Serializer.config.jsonapi_toplevel_meta
+              }
+            }
+            object[:jsonapi].reject! { |_, v| v.blank? }
+
+            object
+          end
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/adapter/json_api/relationship.rb

@@ -0,0 +1,27 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        class Relationship
+          # NOTE(beauby): Currently only `data` is used.
+          attr_accessor :data, :meta, :links
+
+          def initialize(hash = {})
+            hash.each { |k, v| send("#{k}=", v) }
+          end
+
+          def to_h
+            data_hash =
+              if data.is_a?(Array)
+                data.map { |ri| ri.respond_to?(:to_h) ? ri.to_h : ri }
+              elsif data
+                data.respond_to?(:to_h) ? data.to_h : data
+              end
+
+            { data: data_hash }
+          end
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/adapter/json_api/resource.rb

@@ -0,0 +1,17 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        Resource = Struct.new(:identifier, :attributes, :relationships) do
+          def to_h
+            hash = identifier.to_h
+            hash[:attributes] = attributes if attributes.any?
+            hash[:relationships] = Hash[relationships.map { |k, v| [k, v.to_h] }] if relationships.any?
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end

lib/active_model/serializer/adapter/json_api/resource_identifier.rb

@@ -0,0 +1,34 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi
+        ResourceIdentifier = Struct.new(:id, :type) do
+          def self.type_for(serializer)
+            return serializer._type if serializer._type
+            if ActiveModel::Serializer.config.jsonapi_resource_type == :singular
+              serializer.object.class.model_name.singular
+            else
+              serializer.object.class.model_name.plural
+            end
+          end
+
+          def self.id_for(serializer)
+            if serializer.respond_to?(:id)
+              serializer.id
+            else
+              serializer.object.id
+            end
+          end
+
+          def self.from_serializer(serializer)
+            new(id_for(serializer), type_for(serializer))
+          end
+
+          def to_h
+            { id: id.to_s, type: type }
+          end
+        end
+      end
+    end
+  end
+end