jsonapi-resources 0.10.7 → 0.11.0.beta2

data/lib/jsonapi/processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Processor
     include Callbacks
@@ -49,7 +51,7 @@ module JSONAPI
 
       verified_filters = resource_klass.verify_filters(filters, context)
 
-      find_options = {
+      options = {
         context: context,
         sort_criteria: sort_criteria,
         paginator: paginator,
@@ -58,20 +60,18 @@ module JSONAPI
         include_directives: include_directives
       }
 
-      resource_set = find_resource_set(resource_klass,
-                                       include_directives,
-                                       find_options)
+      resource_set = find_resource_set(include_directives, options)
 
-      resource_set.populate!(serializer, context, find_options)
+      resource_set.populate!(serializer, context, options)
 
       page_options = result_options
-      if (top_level_meta_include_record_count || (paginator && paginator.requires_record_count))
+      if (JSONAPI.configuration.top_level_meta_include_record_count || (paginator && paginator.class.requires_record_count))
         page_options[:record_count] = resource_klass.count(verified_filters,
                                                            context: context,
                                                            include_directives: include_directives)
       end
 
-      if (top_level_meta_include_page_count && paginator && page_options[:record_count])
+      if (JSONAPI.configuration.top_level_meta_include_page_count && paginator && page_options[:record_count])
         page_options[:page_count] = paginator ? paginator.calculate_page_count(page_options[:record_count]) : 1
       end
 
@@ -79,7 +79,7 @@ module JSONAPI
         page_options[:pagination_params] = paginator.links_page_params(page_options.merge(fetched_resources: resource_set))
       end
 
-      return JSONAPI::ResourcesSetOperationResult.new(:ok, resource_set, page_options)
+      JSONAPI::ResourcesSetOperationResult.new(:ok, resource_set, page_options)
     end
 
     def show
@@ -90,26 +90,25 @@ module JSONAPI
 
       key = resource_klass.verify_key(id, context)
 
-      find_options = {
+      options = {
         context: context,
         fields: fields,
         filters: { resource_klass._primary_key => key },
         include_directives: include_directives
       }
 
-      resource_set = find_resource_set(resource_klass,
-                                       include_directives,
-                                       find_options)
+      resource_set = find_resource_set(include_directives, options)
 
       fail JSONAPI::Exceptions::RecordNotFound.new(id) if resource_set.resource_klasses.empty?
-      resource_set.populate!(serializer, context, find_options)
+      resource_set.populate!(serializer, context, options)
 
-      return JSONAPI::ResourceSetOperationResult.new(:ok, resource_set, result_options)
+      JSONAPI::ResourceSetOperationResult.new(:ok, resource_set, result_options)
     end
 
     def show_relationship
       parent_key = params[:parent_key]
       relationship_type = params[:relationship_type].to_sym
+      relationship = resource_klass._relationship(relationship_type)
       paginator = params[:paginator]
       sort_criteria = params[:sort_criteria]
       include_directives = params[:include_directives]
@@ -117,25 +116,26 @@ module JSONAPI
 
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
-      find_options = {
-          context: context,
-          sort_criteria: sort_criteria,
-          paginator: paginator,
-          fields: fields,
-          include_directives: include_directives
+      options = {
+        context: context,
+        sort_criteria: sort_criteria,
+        paginator: paginator,
+        fields: fields,
+        include_directives: include_directives
       }
 
-      resource_id_tree = find_related_resource_id_tree(resource_klass,
-                                                       JSONAPI::ResourceIdentity.new(resource_klass, parent_key),
-                                                       relationship_type,
-                                                       find_options,
-                                                       nil)
-
-      return JSONAPI::RelationshipOperationResult.new(:ok,
-                                                      parent_resource,
-                                                      resource_klass._relationship(relationship_type),
-                                                      resource_id_tree.fragments.keys,
-                                                      result_options)
+      resource_tree = find_related_resource_tree(
+        parent_resource,
+        relationship,
+        options,
+        nil
+      )
+
+      JSONAPI::RelationshipOperationResult.new(:ok,
+                                               parent_resource,
+                                               relationship,
+                                               resource_tree.fragments.keys,
+                                               result_options)
     end
 
     def show_related_resource
@@ -146,11 +146,11 @@ module JSONAPI
       serializer = params[:serializer]
       fields = params[:fields]
 
-      find_options = {
-          context: context,
-          fields: fields,
-          filters: {},
-          include_directives: include_directives
+      options = {
+        context: context,
+        fields: fields,
+        filters: {},
+        include_directives: include_directives
       }
 
       source_resource = source_klass.find_by_key(source_id, context: context, fields: fields)
@@ -158,11 +158,11 @@ module JSONAPI
       resource_set = find_related_resource_set(source_resource,
                                                relationship_type,
                                                include_directives,
-                                               find_options)
+                                               options)
 
-      resource_set.populate!(serializer, context, find_options)
+      resource_set.populate!(serializer, context, options)
 
-      return JSONAPI::ResourceSetOperationResult.new(:ok, resource_set, result_options)
+      JSONAPI::ResourceSetOperationResult.new(:ok, resource_set, result_options)
     end
 
     def show_related_resources
@@ -178,8 +178,8 @@ module JSONAPI
 
       verified_filters = resource_klass.verify_filters(filters, context)
 
-      find_options = {
-        filters:  verified_filters,
+      options = {
+        filters: verified_filters,
         sort_criteria: sort_criteria,
         paginator: paginator,
         fields: fields,
@@ -192,38 +192,40 @@ module JSONAPI
       resource_set = find_related_resource_set(source_resource,
                                                relationship_type,
                                                include_directives,
-                                               find_options)
+                                               options)
 
-      resource_set.populate!(serializer, context, find_options)
+      resource_set.populate!(serializer, context, options)
 
       opts = result_options
-      if ((top_level_meta_include_record_count) ||
-          (paginator && paginator.requires_record_count) ||
-          (top_level_meta_include_page_count))
+      if ((JSONAPI.configuration.top_level_meta_include_record_count) ||
+        (paginator && paginator.class.requires_record_count) ||
+        (JSONAPI.configuration.top_level_meta_include_page_count))
+
+        relationship = source_resource.class._relationship(relationship_type)
 
         opts[:record_count] = source_resource.class.count_related(
-            source_resource.identity,
-            relationship_type,
-            find_options)
+          source_resource,
+          relationship,
+          options)
       end
 
-      if (top_level_meta_include_page_count && opts[:record_count])
+      if (JSONAPI.configuration.top_level_meta_include_page_count && opts[:record_count])
         opts[:page_count] = paginator.calculate_page_count(opts[:record_count])
       end
 
       opts[:pagination_params] = if paginator && JSONAPI.configuration.top_level_links_include_pagination
                                    page_options = {}
-                                   page_options[:record_count] = opts[:record_count] if paginator.requires_record_count
+                                   page_options[:record_count] = opts[:record_count] if paginator.class.requires_record_count
                                    paginator.links_page_params(page_options.merge(fetched_resources: resource_set))
                                  else
                                    {}
                                  end
 
-      return JSONAPI::RelatedResourcesSetOperationResult.new(:ok,
-                                                             source_resource,
-                                                             relationship_type,
-                                                             resource_set,
-                                                             opts)
+      JSONAPI::RelatedResourcesSetOperationResult.new(:ok,
+                                                      source_resource,
+                                                      relationship_type,
+                                                      resource_set,
+                                                      opts)
     end
 
     def create_resource
@@ -235,20 +237,18 @@ module JSONAPI
       resource = resource_klass.create(context)
       result = resource.replace_fields(data)
 
-      find_options = {
-          context: context,
-          fields: fields,
-          filters: { resource_klass._primary_key => resource.id },
-          include_directives: include_directives
+      options = {
+        context: context,
+        fields: fields,
+        filters: { resource_klass._primary_key => resource.id },
+        include_directives: include_directives
       }
 
-      resource_set = find_resource_set(resource_klass,
-                                       include_directives,
-                                       find_options)
+      resource_set = find_resource_set(include_directives, options)
 
-      resource_set.populate!(serializer, context, find_options)
+      resource_set.populate!(serializer, context, options)
 
-      return JSONAPI::ResourceSetOperationResult.new((result == :completed ? :created : :accepted), resource_set, result_options)
+      JSONAPI::ResourceSetOperationResult.new((result == :completed ? :created : :accepted), resource_set, result_options)
     end
 
     def remove_resource
@@ -257,7 +257,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.remove
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def replace_fields
@@ -272,20 +272,18 @@ module JSONAPI
 
       result = resource.replace_fields(data)
 
-      find_options = {
-          context: context,
-          fields: fields,
-          filters: { resource_klass._primary_key => resource.id },
-          include_directives: include_directives
+      options = {
+        context: context,
+        fields: fields,
+        filters: { resource_klass._primary_key => resource.id },
+        include_directives: include_directives
       }
 
-      resource_set = find_resource_set(resource_klass,
-                                       include_directives,
-                                       find_options)
+      resource_set = find_resource_set(include_directives, options)
 
-      resource_set.populate!(serializer, context, find_options)
+      resource_set.populate!(serializer, context, options)
 
-      return JSONAPI::ResourceSetOperationResult.new((result == :completed ? :ok : :accepted), resource_set, result_options)
+      JSONAPI::ResourceSetOperationResult.new((result == :completed ? :ok : :accepted), resource_set, result_options)
     end
 
     def replace_to_one_relationship
@@ -296,7 +294,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.replace_to_one_link(relationship_type, key_value)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def replace_polymorphic_to_one_relationship
@@ -308,7 +306,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.replace_polymorphic_to_one_link(relationship_type, key_value, key_type)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def create_to_many_relationships
@@ -319,7 +317,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.create_to_many_links(relationship_type, data)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def replace_to_many_relationships
@@ -330,7 +328,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.replace_to_many_links(relationship_type, data)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def remove_to_many_relationships
@@ -347,7 +345,7 @@ module JSONAPI
           complete = false
         end
       end
-      return JSONAPI::OperationResult.new(complete ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(complete ? :no_content : :accepted, result_options)
     end
 
     def remove_to_one_relationship
@@ -357,7 +355,7 @@ module JSONAPI
       resource = resource_klass.find_by_key(resource_id, context: context)
       result = resource.remove_to_one_link(relationship_type)
 
-      return JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
+      JSONAPI::OperationResult.new(result == :completed ? :no_content : :accepted, result_options)
     end
 
     def result_options
@@ -366,99 +364,48 @@ module JSONAPI
       options
     end
 
-    def find_resource_set(resource_klass, include_directives, options)
-      include_related = include_directives.include_directives[:include_related] if include_directives
+    def find_resource_set(include_directives, options)
+      include_related = include_directives[:include_related] if include_directives
 
-      resource_id_tree = find_resource_id_tree(resource_klass, options, include_related)
+      resource_tree = find_resource_tree(options, include_related)
 
-      JSONAPI::ResourceSet.new(resource_id_tree)
+      JSONAPI::ResourceSet.new(resource_tree)
     end
 
     def find_related_resource_set(resource, relationship_name, include_directives, options)
-      include_related = include_directives.include_directives[:include_related] if include_directives
-
-      resource_id_tree = find_resource_id_tree_from_resource_relationship(resource, relationship_name, options, include_related)
+      include_related = include_directives[:include_related] if include_directives
 
-      JSONAPI::ResourceSet.new(resource_id_tree)
-    end
-
-    def top_level_meta_include_record_count
-      JSONAPI.configuration.top_level_meta_include_record_count
-    end
+      resource_tree = find_resource_tree_from_relationship(resource, relationship_name, options, include_related)
 
-    def top_level_meta_include_page_count
-      JSONAPI.configuration.top_level_meta_include_page_count
+      JSONAPI::ResourceSet.new(resource_tree)
     end
 
-    private
-    def find_related_resource_id_tree(resource_klass, source_id, relationship_name, find_options, include_related)
-      options = find_options.except(:include_directives)
+    def find_resource_tree(options, include_related)
       options[:cache] = resource_klass.caching?
 
-      fragments = resource_klass.find_included_fragments([source_id], relationship_name, options)
-
-      primary_resource_id_tree = PrimaryResourceIdTree.new
-      primary_resource_id_tree.add_resource_fragments(fragments, include_related)
-
-      load_included(resource_klass, primary_resource_id_tree, include_related, options)
-
-      primary_resource_id_tree
+      fragments = resource_klass.find_fragments(options[:filters], options)
+      PrimaryResourceTree.new(fragments: fragments, include_related: include_related, options: options)
     end
 
-    def find_resource_id_tree(resource_klass, find_options, include_related)
-      options = find_options
+    def find_related_resource_tree(parent_resource, relationship, options, include_related)
+      options = options.except(:include_directives)
       options[:cache] = resource_klass.caching?
 
-      fragments = resource_klass.find_fragments(find_options[:filters], options)
-
-      primary_resource_id_tree = PrimaryResourceIdTree.new
-      primary_resource_id_tree.add_resource_fragments(fragments, include_related)
+      parent_resource_fragment = parent_resource.fragment(primary: true)
 
-      load_included(resource_klass, primary_resource_id_tree, include_related, options)
-
-      primary_resource_id_tree
+      fragments = resource_klass.find_related_fragments(parent_resource_fragment, relationship, options)
+      PrimaryResourceTree.new(fragments: fragments, include_related: include_related, options: options)
     end
 
-    def find_resource_id_tree_from_resource_relationship(resource, relationship_name, find_options, include_related)
+    def find_resource_tree_from_relationship(resource, relationship_name, options, include_related)
       relationship = resource.class._relationship(relationship_name)
 
-      options = find_options.except(:include_directives)
+      options = options.except(:include_directives)
       options[:cache] = relationship.resource_klass.caching?
 
-      fragments = resource.class.find_related_fragments([resource.identity], relationship_name, options)
-
-      primary_resource_id_tree = PrimaryResourceIdTree.new
-      primary_resource_id_tree.add_resource_fragments(fragments, include_related)
+      fragments = resource.class.find_related_fragments(resource.fragment, relationship, options)
 
-      load_included(resource_klass, primary_resource_id_tree, include_related, options)
-
-      primary_resource_id_tree
-    end
-
-    def load_included(resource_klass, source_resource_id_tree, include_related, options)
-      source_rids = source_resource_id_tree.fragments.keys
-
-      include_related.try(:each_key) do |key|
-        relationship = resource_klass._relationship(key)
-        relationship_name = relationship.name.to_sym
-
-        find_related_resource_options = options.except(:filters, :sort_criteria, :paginator)
-        find_related_resource_options[:sort_criteria] = relationship.resource_klass.default_sort
-        find_related_resource_options[:cache] = resource_klass.caching?
-
-        related_fragments = resource_klass.find_included_fragments(
-          source_rids, relationship_name, find_related_resource_options
-        )
-
-        related_resource_id_tree = source_resource_id_tree.fetch_related_resource_id_tree(relationship)
-        related_resource_id_tree.add_resource_fragments(related_fragments, include_related[key][include_related])
-
-        # Now recursively get the related resources for the currently found resources
-        load_included(relationship.resource_klass,
-                      related_resource_id_tree,
-                      include_related[relationship_name][:include_related],
-                      options)
-      end
+      PrimaryResourceTree.new(fragments: fragments, include_related: include_related, options: options)
     end
   end
 end