json_api_resource 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d614a8696dc5d0a00cec60e488cc0bf2525b90f0
-  data.tar.gz: 98c045571f29a19bc8923631bc536a5605c049b4
+  metadata.gz: 550d3bf8b009a60ef20065c2131601ec524a0761
+  data.tar.gz: 822dca3ef57832f3fecc4c18c0bb1f52e846c1bf
 SHA512:
-  metadata.gz: f1ab7d5d28bcd0d327469b3d8a0c96900df625288b0f5e7cd926dbc2b867a282ee23b1ed69834c3192a8361451451bf11cb7011fa52fd59a683e3116e83b778f
-  data.tar.gz: 3a8b5589a2cab870d1a1548a7afdb659f2dde36fa655d16d2d36e7e1959703a1beede2621791197cbd6709c60917bdd3884ae9dab60a46c3ef9794b3f43b8a99
+  metadata.gz: 21426386df0e1e7bda458f3b3aaeff65cf415cdca85c03792b6ac9079b75a9f8d249d40161b572070463ff596ba30ec7841e9b7d05ba9b18f2609a24138556b2
+  data.tar.gz: f559ca29883f3f3f5f08800c19825402fdc7520a26f28020c8e26eb53097f6250302a673cd9b03ce2076a1df3fa67724c592d3510f9ca8ab20cd816457866b18

data/README.md

@@ -140,6 +140,109 @@ NOTE: all properties are optional. If you don't have it defined and it's in the
 
 The object will still reply to `id`, `name` and `permissions`, but you won't be able to assume they are there, and they will not appear when you do `ResourceClass.new`.
 
+### Associations
+
+#### interface
+
+* `belongs_to` - your resource has the `#{object}_id` for the association.
+  * calls `object_class.find `
+* `has_one` - will call the server with `opts.merge "#{root_class}_id => root_object.id` and grab the first thing that comes back
+  * calls `object_class.where`
+* `has_many` - same as `has_one` but will give you the full array of objects
+  * calls 'object_class.where`
+
+#### options
+
+* `:foreign_key` - this is what the server will get as the key for `has_one` and `has_many`. `belongs_to` is weird and will send the key to the resource object. for example
+```ruby
+class Admin < JsonApiResource::Resource
+  wraps Service::Client::Admin
+
+  property user_id
+  # this one is a little weird
+  belongs_to :person, foreign_key: :user_id, class: User
+end
+```
+* `:action` - If you have a custom action you're using for lookup, you can override the default `where` and `find`. For example
+```ruby
+class Service::Client::Superuser < Service::Client::Base
+  # i don't know why you would have this, but whatever
+  custom_endpoint :superuser_from_user_id, :on=> :collection, :request_method=> :get
+end
+
+class User
+  wraps Service::Client::User
+  has_one :superuser, action: :superuser_from_user_id
+end
+```
+*NOTE: keep in mind, this will still make the call with the `opts.merge foreign_key => root_object.id` hash. If you want to override the query, you may want to consider 1: if the API is RESTful 2: rolling your own association.*
+
+* `:prefetched_ids` *(`has_many` only)* -  in the case that the root object has a collection of ids that come preloaded in it
+```ruby
+class User < JsonApiResource::Resource
+  wraps Service::Client::User
+  property address_ids, []
+
+  has_many :addresses, prefetched_ids: :address_ids
+end
+```
+
+
+#### notes
+* `:through` is not supported, nor will it ever be, because of the hidden complexity and cost of n HTTP calls. if you want to implement `through` do
+
+* the servers you're preloading from/associating have controller entities that respond to show(`find`) and index(`where`)
+* __important__: the index(`where`) action has to support `ingore_pagination`. Otherwise you may lose associations as they get capped by the per-page limit
+
+### Preloader
+
+Sometimes you have many objects that you need to fetch associations for. It's expensive to have to iterate over them one by one and annoying to have to assign the results. Well, now there's a `Preloader` that can do all of that for you
+
+#### example
+
+Let's say you have `user`s who have `address`es. 
+```ruby
+class User < JsonApiResource::Resource
+  wraps Service::Client::User
+
+  # shiny new function yay
+  has_many :addresses
+end
+
+class Address < JsonApiResource::Resource
+  wraps Service::Client::Address
+end
+```
+
+With the associations in place, you can now use them to preload all the addresses for your users in a single query.
+
+```ruby
+@users = User.where id: [1, 2, 3, 4, 5]
+
+# that's it. that's all you have to do.
+JsonApiClient::Associations::Preloader.preload @users, :addresses
+
+# all the users now have addresses assigned to them and will not hit the server again
+puts @users.map &:addresses
+```
+
+#### interface
+
+`Preloader.preload( objects, preloads )` takes
+
+* the objects you want the associations to be tied to (`@users` in our example)
+* the list of associations you want bulk fetched from the server as symbols. 
+  * can be a single symbol, or a list
+  * has to have a corresponding association on the objects, and the name has to match
+
+#### notes
+
+This is a simple tool so don't expect too much magic. The Preloader will explode if
+
+* the objects aren't the same class
+* the results aren't the same class (although i don't know how that would be possible)
+* the result set can't be matched to the objects
+
 ### Error Handling
 
 On an unsuccessful call to the server (this means that if you have multiple connections, they will *necessarily* **all** have to fail), errors will be routed through an overridable `handle_failed_request(e)` method. By default it will re-raise the error, but you can handle it any way you want. 

data/lib/json_api_resource.rb

@@ -1,6 +1,8 @@
 require 'json_api_client'
 
 module JsonApiResource
+  autoload :Associatable,           'json_api_resource/associatable'
+  autoload :Associations,           'json_api_resource/associations'
   autoload :Cacheable,              'json_api_resource/cacheable'
   autoload :Clientable,             'json_api_resource/clientable'
   autoload :Connections,            'json_api_resource/connections'

data/lib/json_api_resource/associatable.rb

@@ -0,0 +1,60 @@
+module JsonApiResource
+  module Associatable
+    extend ActiveSupport::Concern
+
+    included do
+
+      class_attribute :_associations
+      self._associations = {}
+
+      attr_accessor :_cached_associations      
+      
+      class << self
+        def belongs_to( name, opts = {} )
+          process Associations::BelongsTo.new( self, name, opts )
+        end
+
+        def has_one( name, opts = {} )
+          process Associations::HasOne.new( self, name, opts )
+        end
+
+        def has_many( name, opts = {} )
+          if opts[:prefetched_ids]
+            process Associations::HasManyPrefetched.new( self, name, opts )
+          else
+            process Associations::HasMany.new( self, name, opts )
+          end
+        end
+
+        private
+
+        def process(association)
+          add_association association
+          methodize association
+        end
+
+        def add_association(association)
+          self._associations = _associations.merge association.name => association
+        end
+
+        def methodize( association )
+          define_method association.name do 
+            self._cached_associations ||= {}
+            unless self._cached_associations.has_key? association.name
+              if association.callable?(self)
+                result = association.klass.send( association.action, association.query(self) )
+                result = association.post_process result
+              else
+                result = association.nil_default
+              end
+              
+              self._cached_associations[association.name] = result
+            end
+            self._cached_associations[association.name]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/json_api_resource/associations.rb

@@ -0,0 +1,17 @@
+module JsonApiResource
+  module Associations
+    autoload :Base,               'json_api_resource/associations/base'
+    autoload :BelongsTo,          'json_api_resource/associations/belongs_to'
+    autoload :HasManyPrefetched,  'json_api_resource/associations/has_many_prefetched'
+    autoload :HasOne,             'json_api_resource/associations/has_one'
+    autoload :HasMany,            'json_api_resource/associations/has_many'
+    autoload :Preloader,          'json_api_resource/associations/preloader'
+    autoload :Preloaders,         'json_api_resource/associations/preloaders'
+
+
+    BELONGS_TO          = :belongs_to
+    HAS_ONE             = :has_one
+    HAS_MANY            = :has_many
+    HAS_MANY_PREFETCHED = :has_many_prefetched
+  end
+end

data/lib/json_api_resource/associations/base.rb

@@ -0,0 +1,79 @@
+module JsonApiResource
+  module Associations
+    class Base
+      include ::JsonApiResource::Errors
+      attr_accessor :name, :action, :key, :root
+
+      def initialize(associated_class, name, opts = {})
+        self.name   = name.to_sym
+        self.root   = associated_class
+        @opts       = opts.merge( skip_pagination: true )
+        
+        self.action = @opts.delete :action       do default_action end
+        self.key    = @opts.delete :foreign_key  do server_key end
+
+        self.key    = self.key.try :to_sym
+        validate_options
+      end
+
+      def type
+        raise NotImplementedError
+      end
+
+      def query( root_insatnce )
+        raise NotImplementedError
+      end
+
+      def callable?( root_insatnce )
+        raise NotImplementedError
+      end
+
+      def default_nil
+        raise NotImplementedError
+      end
+
+      # klass has to be lazy initted for circular dependencies
+      def klass
+        @klass ||= @opts.delete :class do derived_class end
+      end
+
+      def post_process( value )
+        value
+      end
+
+      def opts
+        @opts.except *ASSOCIATION_OPTS
+      end
+
+      protected
+
+      def server_key
+        raise NotImplementedError
+      end
+      
+      def default_action
+        raise NotImplementedError
+      end
+
+      def derived_class
+        module_string = self.root.to_s.split("::")[0 ... -1].join("::")
+        class_string  = name.to_s.singularize.camelize
+        
+        # we don't necessarily want to add :: to classes, in case they have a relative path or something
+        class_string = [module_string, class_string].select{|s| s.present? }.join "::"
+        class_string.constantize
+      end
+
+      ASSOCIATION_OPTS  = [:class, :action, :foreign_key, :prefetched_ids]
+
+      RESERVED_KEYWORDS = [:attributes, :_associations, :_cached_associations, :schema, :client]
+
+      def validate_options
+        raise_unless action.present?, "Invalid action: #{self.root}.#{name}"
+        raise_unless    key.present?, "Invalid foreign_key for #{self.root}.#{name}"
+
+        raise_if RESERVED_KEYWORDS.include?(name), "'#{name}' is a reserved keyword for #{self.root}"
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/belongs_to.rb

@@ -0,0 +1,29 @@
+module JsonApiResource
+  module Associations
+    class BelongsTo < Base
+      def default_action
+        :find
+      end
+
+      def server_key
+        "#{name}_id"
+      end
+
+      def query( root_instance )
+        root_instance.send key
+      end
+
+      def callable?( root_instance )
+        root_instance.send(key).present?
+      end
+
+      def nil_default
+        nil
+      end
+
+      def type
+        JsonApiResource::Associations::BELONGS_TO
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/has_many.rb

@@ -0,0 +1,26 @@
+module JsonApiResource
+  module Associations
+    class HasMany < Base
+      def default_action
+        :where
+      end
+
+      def server_key
+        class_name = self.root.to_s.demodulize.underscore
+        "#{class_name}_id"
+      end
+
+      def callable?( root_instance )
+        true
+      end
+
+      def query( root_instance )
+        { key => root_instance.id }.merge(opts)
+      end
+
+      def type
+        JsonApiResource::Associations::HAS_MANY
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/has_many_prefetched.rb

@@ -0,0 +1,34 @@
+module JsonApiResource
+  module Associations
+    class HasManyPrefetched < Base
+      def default_action
+        :where
+      end
+
+      def server_key
+        @opts[:prefetched_ids]
+      end
+
+      def query( root_instance )
+        { id: root_instance.send(key) }.merge(opts)
+      end
+
+      def callable?( root_instance )
+        root_instance.send(key).present?
+      end
+
+      def nil_default
+        []
+      end
+
+      def type
+        JsonApiResource::Associations::HAS_MANY_PREFETCHED
+      end
+
+      def validate_options
+        raise_unless key == server_key, "#{root}.#{name} cannot specify both prefetched_ids and a foreign key"
+        super
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/has_one.rb

@@ -0,0 +1,30 @@
+module JsonApiResource
+  module Associations
+    class HasOne < Base
+      def post_process( value )
+        Array(value).first
+      end
+
+      def default_action  
+        :where
+      end
+
+      def server_key
+        class_name = self.root.to_s.demodulize.underscore
+        "#{class_name}_id"
+      end
+
+      def query( root_instance )
+        { key => root_instance.id }.merge(opts)
+      end
+
+      def callable?( root_instance )
+        true
+      end
+
+      def type
+        JsonApiResource::Associations::HAS_ONE
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloader.rb

@@ -0,0 +1,58 @@
+module JsonApiResource
+  module Associations
+    class Preloader
+      include JsonApiResource::Errors
+
+      class << self
+        def preload ( objects, preloads )
+          objects  = Array(objects)
+          preloads = Array(preloads)
+          
+          preloads.each do |preload|
+
+            association = association_for objects, preload
+            
+            preloader   = preloader_for association
+
+            preloader.preload( objects )
+
+          end
+        end
+
+        private
+
+        def association_for( objects, preload )
+          # let's assert the objects are of a single class
+          verify_object_homogenity!(objects)
+
+          obj_class   = objects.first.class
+          association = obj_class._associations[preload]
+          
+          raise_if association.nil?, "'#{preload}' is not a valid association on #{obj_class}"
+
+          association
+        end
+
+        def preloader_for( association )
+          preloader_class = PREOLOADERS_FOR_ASSOCIATIONS[association.type]
+          preloader_class.new association
+        end
+
+        def verify_object_homogenity!( objects )
+          obj_class = objects.first.class
+          
+          objects.each do |obj|
+            raise_unless obj.is_a?(obj_class), "JsonApiResource::Associations::Preloader.preload called with a heterogenious array of objects."
+          end
+        end
+
+        PREOLOADERS_FOR_ASSOCIATIONS = {
+                                          JsonApiResource::Associations::BELONGS_TO          => JsonApiResource::Associations::Preloaders::BelongsToPreloader,
+                                          JsonApiResource::Associations::HAS_ONE             => JsonApiResource::Associations::Preloaders::HasOnePreloader,
+                                          JsonApiResource::Associations::HAS_MANY            => JsonApiResource::Associations::Preloaders::HasManyPreloader,
+                                          JsonApiResource::Associations::HAS_MANY_PREFETCHED => JsonApiResource::Associations::Preloaders::HasManyPrefetchedPreloader,
+                                        }
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders.rb

@@ -0,0 +1,12 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      autoload :Base,                         'json_api_resource/associations/preloaders/base'
+      autoload :BelongsToPreloader,           'json_api_resource/associations/preloaders/belongs_to_preloader'
+      autoload :Distributors,                 'json_api_resource/associations/preloaders/distributors'
+      autoload :HasManyPrefetchedPreloader,   'json_api_resource/associations/preloaders/has_many_prefetched_preloader'
+      autoload :HasManyPreloader,             'json_api_resource/associations/preloaders/has_many_preloader'
+      autoload :HasOnePreloader,              'json_api_resource/associations/preloaders/has_one_preloader'
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/base.rb

@@ -0,0 +1,38 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      class Base
+        include JsonApiResource::Errors
+
+        attr_accessor :association, :distributor
+        delegate :klass, :name, :action, :key, :opts, :post_process, to: :association
+
+        def initialize(association)
+          self.association = association
+          self.distributor = distributor_class.new association
+        end
+
+        def preload( objects )
+          query       = bulk_query( objects )
+          results     = klass.send action, query
+
+          distributor.distribute objects, results
+        end
+
+        private
+
+        def assign( objects, results )
+          raise NotImplementedError
+        end
+
+        def bulk_query( objects )
+          raise NotImplementedError
+        end
+
+        def distributor_class
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/belongs_to_preloader.rb

@@ -0,0 +1,17 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      class BelongsToPreloader < Base
+
+        def bulk_query( objects )
+          ids = objects.map{ |o| o.send(key) }.flatten.uniq
+          { id: ids }.merge(opts)
+        end
+
+        def distributor_class
+          JsonApiResource::Associations::Preloaders::Distributors::DistributorByTargetId
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/distributors.rb

@@ -0,0 +1,11 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      module Distributors
+        autoload :Base,                   'json_api_resource/associations/preloaders/distributors/base'
+        autoload :DistributorByObjectId,  'json_api_resource/associations/preloaders/distributors/distributor_by_object_id'
+        autoload :DistributorByTargetId,  'json_api_resource/associations/preloaders/distributors/distributor_by_target_id'
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/distributors/base.rb

@@ -0,0 +1,33 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      module Distributors
+        class Base
+          include JsonApiResource::Errors
+
+          attr_accessor :association
+          delegate :key, :post_process, :root, :name, to: :association
+
+          def initialize(association)
+            self.association = association
+          end
+
+          def distribute( targets, resutls )
+            validate_assignability!( resutls )
+            assign( targets, resutls )
+          end
+
+          private
+
+          def validate_assignability!( resutls )
+            raise NotImplementedError
+          end
+
+          def assign( targets, resutls )
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/distributors/distributor_by_object_id.rb

@@ -0,0 +1,28 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      module Distributors
+        class DistributorByObjectId < Base
+
+          def assign( targets, results )
+            targets.each do |target|
+                        
+              id = target.id
+              
+              result = results.select{ |r| r.send(key) == id }
+
+              target._cached_associations ||= {}
+              target._cached_associations[name] = post_process result
+            end
+          end
+
+          def validate_assignability!( results )
+            results.each do |obj|
+              raise_unless obj.respond_to?(key), "preloading #{root}.#{name} failed: results don't respond to '#{key}'"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/distributors/distributor_by_target_id.rb

@@ -0,0 +1,32 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      module Distributors
+        class DistributorByTargetId < Base
+
+          def assign( targets, results )
+            targets.each do |target|
+              
+              ids = Array(target.send(key))
+              
+              # this obejct doesn't have this association. skip
+              next unless ids.present?
+                
+              result = results.select{ |r| ids.include? r.id }
+
+              target._cached_associations ||= {}
+              target._cached_associations[name] = post_process result
+
+            end
+          end
+
+          def validate_assignability!( results )
+            results.each do |obj|
+              raise_unless obj.respond_to?(:id), "preloading #{root}.#{name} failed: results don't respond to 'id'"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/has_many_prefetched_preloader.rb

@@ -0,0 +1,17 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      class HasManyPrefetchedPreloader < Base
+
+        def bulk_query( objects )
+          ids = objects.map{ |o| o.send(key) }.flatten.uniq
+          { id: ids }.merge(opts)
+        end
+
+        def distributor_class
+          JsonApiResource::Associations::Preloaders::Distributors::DistributorByTargetId
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/has_many_preloader.rb

@@ -0,0 +1,17 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      class HasManyPreloader < Base
+
+        def bulk_query( objects )
+          ids = objects.map(&:id)
+          { key => ids }.merge(opts)
+        end
+
+        def distributor_class
+          JsonApiResource::Associations::Preloaders::Distributors::DistributorByObjectId
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/associations/preloaders/has_one_preloader.rb

@@ -0,0 +1,17 @@
+module JsonApiResource
+  module Associations
+    module Preloaders
+      class HasOnePreloader < Base
+
+        def bulk_query( objects )
+          ids = objects.map(&:id)
+          { key => ids }.merge(opts)
+        end
+
+        def distributor_class
+          JsonApiResource::Associations::Preloaders::Distributors::DistributorByObjectId
+        end
+      end
+    end
+  end
+end

data/lib/json_api_resource/errors.rb

@@ -1,5 +1,29 @@
 module JsonApiResource
   module Errors
+    extend ActiveSupport::Concern
+    included do
+
+      def raise_if( condition, message, error = JsonApiResource::Errors::InvalidAssociation )
+        self.class.raise_if condition, message, error
+      end
+
+      def raise_unless( condition, message, error = JsonApiResource::Errors::InvalidAssociation )
+        raise_if !condition, message, error
+      end
+
+
+      class << self
+
+        def raise_if( condition, message, error = JsonApiResource::Errors::InvalidAssociation )
+          raise error.new(class: self, message: message ) if condition
+        end
+
+        def raise_unless( condition, message, error = JsonApiResource::Errors::InvalidAssociation )
+          raise_if !condition, message, error
+        end
+      end
+    end
+
     class JsonApiResourceError < StandardError
       def initialize(opts = {})
         @klass    = opts.fetch :class, JsonApiResource::Resource
@@ -13,5 +37,8 @@ module JsonApiResource
 
     class UnsuccessfulRequest < JsonApiResourceError
     end
+
+    class InvalidAssociation < JsonApiResourceError
+    end
   end
 end

data/lib/json_api_resource/resource.rb

@@ -24,6 +24,8 @@ module JsonApiResource
     include JsonApiResource::Conversions
     include JsonApiResource::Cacheable
     include JsonApiResource::ErrorHandleable
+    include JsonApiResource::Errors
+    include JsonApiResource::Associatable
 
     attr_accessor :client, :cache_expires_in
     class_attribute :per_page
@@ -31,7 +33,7 @@ module JsonApiResource
     delegate :to_json, to: :attributes
 
     def initialize(opts={})
-      raise( JsonApiResource::Errors::JsonApiResourceError, class: self.class, message: "A resource must have a client class" ) unless client_class.present?
+      raise_unless client_class.present?, "A resource must have a client class", JsonApiResource::Errors::JsonApiResourceError
 
       self.attributes = opts
       self.errors = ActiveModel::Errors.new(self)

data/lib/json_api_resource/version.rb

@@ -1,3 +1,3 @@
 module JsonApiResource
-  VERSION = "3.0.1"
+  VERSION = "3.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_api_resource
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Brandon Sislow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-16 00:00:00.000000000 Z
+date: 2016-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_api_client
@@ -104,6 +104,24 @@ files:
 - README.md
 - Rakefile
 - lib/json_api_resource.rb
+- lib/json_api_resource/associatable.rb
+- lib/json_api_resource/associations.rb
+- lib/json_api_resource/associations/base.rb
+- lib/json_api_resource/associations/belongs_to.rb
+- lib/json_api_resource/associations/has_many.rb
+- lib/json_api_resource/associations/has_many_prefetched.rb
+- lib/json_api_resource/associations/has_one.rb
+- lib/json_api_resource/associations/preloader.rb
+- lib/json_api_resource/associations/preloaders.rb
+- lib/json_api_resource/associations/preloaders/base.rb
+- lib/json_api_resource/associations/preloaders/belongs_to_preloader.rb
+- lib/json_api_resource/associations/preloaders/distributors.rb
+- lib/json_api_resource/associations/preloaders/distributors/base.rb
+- lib/json_api_resource/associations/preloaders/distributors/distributor_by_object_id.rb
+- lib/json_api_resource/associations/preloaders/distributors/distributor_by_target_id.rb
+- lib/json_api_resource/associations/preloaders/has_many_prefetched_preloader.rb
+- lib/json_api_resource/associations/preloaders/has_many_preloader.rb
+- lib/json_api_resource/associations/preloaders/has_one_preloader.rb
 - lib/json_api_resource/cacheable.rb
 - lib/json_api_resource/clientable.rb
 - lib/json_api_resource/connections.rb
@@ -140,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Build wrapper/adapter objects around JsonApiClient instances