Allow recursive sideloading

This allows things like

?include=children.children.children

To have the correct namespace, so

?filter[children.children][name]=foo

will work

Author: Lee Richmond

lib/jsonapi_compliable.rb

@@ -22,6 +22,7 @@
 require "jsonapi_compliable/util/relationship_payload"
 require "jsonapi_compliable/util/persistence"
 require "jsonapi_compliable/util/validation_response"
+require "jsonapi_compliable/util/sideload"
 
 # require correct jsonapi-rb before extensions
 if defined?(Rails)

lib/jsonapi_compliable/query.rb

@@ -173,9 +173,11 @@ def association?(name)
     end
 
     def parse_include(memo, incl_hash, namespace)
+      memo[namespace] ||= self.class.default_hash
       memo[namespace].merge!(include: incl_hash)
 
       incl_hash.each_pair do |key, sub_hash|
+        key = Util::Sideload.namespace(namespace, key)
         memo.merge!(parse_include(memo, sub_hash, key))
       end
 

lib/jsonapi_compliable/scope.rb

@@ -81,7 +81,8 @@ def sideload(results, includes)
 
       includes.each_pair do |name, nested|
         sideload = @resource.sideload(name)
-        sideload.resolve(results, @query)
+        namespace = Util::Sideload.namespace(@namespace, sideload.name)
+        sideload.resolve(results, @query, namespace)
       end
     end
 

lib/jsonapi_compliable/sideload.rb

@@ -264,9 +264,7 @@ def group_by(grouping_field)
     # @see Resource#with_context
     # @return [void]
     # @api private
-    def resolve(parents, query, namespace = nil)
-      namespace ||= name
-
+    def resolve(parents, query, namespace)
       if polymorphic?
         resolve_polymorphic(parents, query)
       else

lib/jsonapi_compliable/util/sideload.rb

@@ -0,0 +1,33 @@
+module JsonapiCompliable
+  module Util
+    # @api private
+    class Sideload
+      # Determine the namespace for the sideload
+      #
+      # In other words, given a query like
+      # /things?include=a.b
+      #
+      # When 'a' is sideloading 'b', b's namespace is 'b'.
+      #
+      # However, consider a recursive tree structure:
+      #
+      # /things?include=children.children
+      #
+      # The first occurrance of "children" will have the namespace
+      # "children", the second will be "children.children" and so forth.
+      #
+      # This is used to match up other criteria in the query:
+      #
+      # ?filter[children.children][a]=b
+      #
+      # @api private
+      def self.namespace(a, b)
+        if a.to_s.split('.')[0] == b.to_s
+          :"#{a}.#{b}"
+        else
+          b
+        end
+      end
+    end
+  end
+end

spec/scope_spec.rb

@@ -24,7 +24,7 @@
     end
 
     context 'when sideloading' do
-      let(:sideload) { double }
+      let(:sideload) { double(name: :books) }
       let(:results)  { double }
 
       before do
@@ -40,10 +40,15 @@
         end
 
         it 'resolves the sideload' do
-          expect(sideload).to receive(:resolve).with(results, query)
+          expect(sideload).to receive(:resolve).with(results, query, sideload.name)
           instance.resolve
         end
 
+        context 'and it is nested within the same namespace' do
+          xit 'resolves with the correct namespace' do
+          end
+        end
+
         context 'but no parents were found' do
           let(:results) { [] }
 

spec/sideload_spec.rb

@@ -66,7 +66,7 @@ def foo
       end
 
       it 'groups parents, then resolves that group' do
-        instance.resolve(parents, query)
+        instance.resolve(parents, query, instance.name)
         expect(parents.first[:child]).to eq({ parent_id: 1 })
       end
     end
@@ -96,11 +96,11 @@ def foo
         expect(JsonapiCompliable::Scope).to receive(:new)
           .with(base_scope, anything, query, default_paginate: false, namespace: :foo)
           .and_return(scope)
-        instance.resolve(parents, query)
+        instance.resolve(parents, query, instance.name)
       end
 
       it 'assigns results to parents' do
-        instance.resolve(parents, query)
+        instance.resolve(parents, query, instance.name)
         expect(parents.first[:child]).to eq({ parent_id: 1 })
       end