jsonapi-resources 0.4.2 → 0.4.3

data/lib/jsonapi/resource.rb

@@ -6,7 +6,7 @@ module JSONAPI
 
     @@resource_types = {}
 
-    attr :context
+    attr_reader :context
     attr_reader :model
 
     define_jsonapi_resources_callbacks :create,
@@ -17,6 +17,7 @@ module JSONAPI
                                        :replace_has_many_links,
                                        :create_has_one_link,
                                        :replace_has_one_link,
+                                       :replace_polymorphic_has_one_link,
                                        :remove_has_many_link,
                                        :remove_has_one_link,
                                        :replace_fields
@@ -48,9 +49,7 @@ module JSONAPI
             completed = (yield == :completed)
           end
 
-          if @save_needed || is_new?
-            completed = (save == :completed)
-          end
+          completed = (save == :completed) if @save_needed || is_new?
         end
       end
 
@@ -81,6 +80,12 @@ module JSONAPI
       end
     end
 
+    def replace_polymorphic_has_one_link(association_type, association_key_value, association_key_type)
+      change :replace_polymorphic_has_one_link do
+        _replace_polymorphic_has_one_link(association_type, association_key_value, association_key_type)
+      end
+    end
+
     def remove_has_many_link(association_type, key)
       change :remove_has_many_link do
         _remove_has_many_link(association_type, key)
@@ -106,11 +111,12 @@ module JSONAPI
 
     # Override this on a resource to customize how the associated records
     # are fetched for a model. Particularly helpful for authorization.
-    def records_for(association_name, options = {})
+    def records_for(association_name, _options = {})
       model.send association_name
     end
 
     private
+
     def save
       run_callbacks :save do
         _save
@@ -132,45 +138,43 @@ module JSONAPI
     # ```
     def _save
       unless @model.valid?
-        raise JSONAPI::Exceptions::ValidationErrors.new(@model.errors.messages)
+        fail JSONAPI::Exceptions::ValidationErrors.new(@model.errors.messages)
       end
 
       if defined? @model.save
         saved = @model.save
-        unless saved
-          raise JSONAPI::Exceptions::SaveFailed.new
-        end
+        fail JSONAPI::Exceptions::SaveFailed.new unless saved
       else
         saved = true
       end
 
       @save_needed = !saved
 
-      return :completed
+      :completed
     end
 
     def _remove
       @model.destroy
 
-      return :completed
+      :completed
     end
 
     def _create_has_many_links(association_type, association_key_values)
       association = self.class._associations[association_type]
 
       association_key_values.each do |association_key_value|
-        related_resource = Resource.resource_for(self.class.module_path + association.type.to_s).find_by_key(association_key_value, context: @context)
+        related_resource = association.resource_klass.find_by_key(association_key_value, context: @context)
 
-        # ToDo: Add option to skip relations that already exist instead of returning an error?
+        # TODO: Add option to skip relations that already exist instead of returning an error?
         relation = @model.send(association.type).where(association.primary_key => association_key_value).first
         if relation.nil?
           @model.send(association.type) << related_resource.model
         else
-          raise JSONAPI::Exceptions::HasManyRelationExists.new(association_key_value)
+          fail JSONAPI::Exceptions::HasManyRelationExists.new(association_key_value)
         end
       end
 
-      return :completed
+      :completed
     end
 
     def _replace_has_many_links(association_type, association_key_values)
@@ -179,7 +183,7 @@ module JSONAPI
       send("#{association.foreign_key}=", association_key_values)
       @save_needed = true
 
-      return :completed
+      :completed
     end
 
     def _replace_has_one_link(association_type, association_key_value)
@@ -188,7 +192,18 @@ module JSONAPI
       send("#{association.foreign_key}=", association_key_value)
       @save_needed = true
 
-      return :completed
+      :completed
+    end
+
+    def _replace_polymorphic_has_one_link(association_type, key_value, key_type)
+      association = self.class._associations[association_type.to_sym]
+
+      model.send("#{association.foreign_key}=", key_value)
+      model.send("#{association.polymorphic_type}=", key_type.to_s.classify)
+
+      @save_needed = true
+
+      :completed
     end
 
     def _remove_has_many_link(association_type, key)
@@ -196,7 +211,7 @@ module JSONAPI
 
       @model.send(association.type).delete(key)
 
-      return :completed
+      :completed
     end
 
     def _remove_has_one_link(association_type)
@@ -205,7 +220,7 @@ module JSONAPI
       send("#{association.foreign_key}=", nil)
       @save_needed = true
 
-      return :completed
+      :completed
     end
 
     def _replace_fields(field_data)
@@ -224,7 +239,12 @@ module JSONAPI
         if value.nil?
           remove_has_one_link(association_type)
         else
-          replace_has_one_link(association_type, value)
+          case value
+          when Hash
+            replace_polymorphic_has_one_link(association_type.to_s, value.fetch(:id), value.fetch(:type))
+          else
+            replace_has_one_link(association_type, value)
+          end
         end
       end if field_data[:has_one]
 
@@ -232,7 +252,7 @@ module JSONAPI
         replace_has_many_links(association_type, values)
       end if field_data[:has_many]
 
-      return :completed
+      :completed
     end
 
     class << self
@@ -253,15 +273,15 @@ module JSONAPI
         resource_name = JSONAPI::Resource._resource_name_from_type(type)
         resource = resource_name.safe_constantize if resource_name
         if resource.nil?
-          raise NameError, "JSONAPI: Could not find resource '#{type}'. (Class #{resource_name} not found)"
+          fail NameError, "JSONAPI: Could not find resource '#{type}'. (Class #{resource_name} not found)"
         end
         resource
       end
 
-      attr_accessor :_attributes, :_associations, :_allowed_filters , :_type, :_paginator
+      attr_accessor :_attributes, :_associations, :_allowed_filters, :_type, :_paginator
 
       def create(context)
-        self.new(self.create_model, context)
+        new(create_model, context)
       end
 
       def create_model
@@ -303,7 +323,7 @@ module JSONAPI
       end
 
       def default_attribute_options
-        {format: :default}
+        { format: :default }
       end
 
       def has_one(*attrs)
@@ -319,7 +339,7 @@ module JSONAPI
       end
 
       def filters(*attrs)
-        @_allowed_filters.merge!(attrs.inject( Hash.new ) { |h, attr| h[attr] = {}; h })
+        @_allowed_filters.merge!(attrs.inject({}) { |h, attr| h[attr] = {}; h })
       end
 
       def filter(attr, *args)
@@ -334,11 +354,11 @@ module JSONAPI
       # :nocov:
       def method_missing(method, *args)
         if method.to_s.match /createable_fields/
-          ActiveSupport::Deprecation.warn("`createable_fields` is deprecated, please use `creatable_fields` instead")
-          self.creatable_fields(*args)
+          ActiveSupport::Deprecation.warn('`createable_fields` is deprecated, please use `creatable_fields` instead')
+          creatable_fields(*args)
         elsif method.to_s.match /updateable_fields/
-          ActiveSupport::Deprecation.warn("`updateable_fields` is deprecated, please use `updatable_fields` instead")
-          self.updatable_fields(*args)
+          ActiveSupport::Deprecation.warn('`updateable_fields` is deprecated, please use `updatable_fields` instead')
+          updatable_fields(*args)
         else
           super
         end
@@ -346,17 +366,17 @@ module JSONAPI
       # :nocov:
 
       # Override in your resource to filter the updatable keys
-      def updatable_fields(context = nil)
+      def updatable_fields(_context = nil)
         _updatable_associations | _attributes.keys - [:id]
       end
 
       # Override in your resource to filter the creatable keys
-      def creatable_fields(context = nil)
+      def creatable_fields(_context = nil)
         _updatable_associations | _attributes.keys
       end
 
       # Override in your resource to filter the sortable keys
-      def sortable_fields(context = nil)
+      def sortable_fields(_context = nil)
         _attributes.keys
       end
 
@@ -364,15 +384,38 @@ module JSONAPI
         _associations.keys | _attributes.keys
       end
 
-      def apply_includes(records, directives)
-        records = records.includes(*directives.model_includes) if directives
+      def resolve_association_names_to_relations(resource_klass, model_includes, options = {})
+        case model_includes
+          when Array
+            return model_includes.map do |value|
+              resolve_association_names_to_relations(resource_klass, value, options)
+            end
+          when Hash
+            model_includes.keys.each do |key|
+              association = resource_klass._associations[key]
+              value = model_includes[key]
+              model_includes.delete(key)
+              model_includes[association.relation_name(options)] = resolve_association_names_to_relations(association.resource_klass, value, options)
+            end
+            return model_includes
+          when Symbol
+            association = resource_klass._associations[model_includes]
+            return association.relation_name(options)
+        end
+      end
+
+      def apply_includes(records, options = {})
+        include_directives = options[:include_directives]
+        if include_directives
+          model_includes = resolve_association_names_to_relations(self, include_directives.model_includes, options)
+          records = records.includes(model_includes)
+        end
+
         records
       end
 
       def apply_pagination(records, paginator, order_options)
-        if paginator
-          records = paginator.apply(records, order_options)
-        end
+        records = paginator.apply(records, order_options) if paginator
         records
       end
 
@@ -384,7 +427,7 @@ module JSONAPI
         end
       end
 
-      def apply_filter(records, filter, value, options = {})
+      def apply_filter(records, filter, value, _options = {})
         records.where(filter => value)
       end
 
@@ -395,7 +438,7 @@ module JSONAPI
           filters.each do |filter, value|
             if _associations.include?(filter)
               if _associations[filter].is_a?(JSONAPI::Association::HasMany)
-                required_includes.push(filter)
+                required_includes.push(filter.to_s)
                 records = apply_filter(records, "#{filter}.#{_associations[filter].primary_key}", value, options)
               else
                 records = apply_filter(records, "#{_associations[filter].foreign_key}", value, options)
@@ -407,20 +450,16 @@ module JSONAPI
         end
 
         if required_includes.any?
-          records.includes(required_includes)
-        elsif records.respond_to? :to_ary
-          records
-        else
-          records.all
+          records = apply_includes(records, options.merge(include_directives: IncludeDirectives.new(required_includes)))
         end
+
+        records
       end
 
       def filter_records(filters, options)
-        include_directives = options[:include_directives]
-
         records = records(options)
-        records = apply_includes(records, include_directives)
-        apply_filters(records, filters, options)
+        records = apply_filters(records, filters, options)
+        apply_includes(records, options)
       end
 
       def sort_records(records, order_options)
@@ -445,27 +484,24 @@ module JSONAPI
 
         resources = []
         records.each do |model|
-          resources.push self.new(model, context)
+          resources.push new(model, context)
         end
 
-        return resources
+        resources
       end
 
       def find_by_key(key, options = {})
         context = options[:context]
-        include_directives = options[:include_directives]
         records = records(options)
-        records = apply_includes(records, include_directives)
+        records = apply_includes(records, options)
         model = records.where({_primary_key => key}).first
-        if model.nil?
-          raise JSONAPI::Exceptions::RecordNotFound.new(key)
-        end
-        self.new(model, context)
+        fail JSONAPI::Exceptions::RecordNotFound.new(key) if model.nil?
+        new(model, context)
       end
 
       # Override this method if you want to customize the relation for
       # finder methods (find, find_by_key)
-      def records(options = {})
+      def records(_options = {})
         _model_class
       end
 
@@ -494,7 +530,7 @@ module JSONAPI
       end
 
       # override to allow for key processing and checking
-      def verify_key(key, context = nil)
+      def verify_key(key, _context = nil)
         key && Integer(key)
       rescue
         raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
@@ -508,13 +544,13 @@ module JSONAPI
       end
 
       # override to allow for custom filters
-      def verify_custom_filter(filter, value, context = nil)
-        return filter, value
+      def verify_custom_filter(filter, value, _context = nil)
+        [filter, value]
       end
 
       # override to allow for custom association logic, such as uuids, multiple keys or permission checks on keys
-      def verify_association_filter(filter, raw, context = nil)
-        return filter, raw
+      def verify_association_filter(filter, raw, _context = nil)
+        [filter, raw]
       end
 
       # quasi private class methods
@@ -523,12 +559,12 @@ module JSONAPI
       end
 
       def _updatable_associations
-        @_associations.map { |key, association| key }
+        @_associations.map { |key, _association| key }
       end
 
       def _has_association?(type)
         type = type.to_s
-        @_associations.has_key?(type.singularize.to_sym) || @_associations.has_key?(type.pluralize.to_sym)
+        @_associations.key?(type.singularize.to_sym) || @_associations.key?(type.pluralize.to_sym)
       end
 
       def _association(type)
@@ -537,7 +573,7 @@ module JSONAPI
       end
 
       def _model_name
-        @_model_name ||= self.name.demodulize.sub(/Resource$/, '')
+        @_model_name ||= name.demodulize.sub(/Resource$/, '')
       end
 
       def _primary_key
@@ -549,13 +585,13 @@ module JSONAPI
       end
 
       def _allowed_filters
-        !@_allowed_filters.nil? ? @_allowed_filters : { :id => {} }
+        !@_allowed_filters.nil? ? @_allowed_filters : { id: {} }
       end
 
       def _resource_name_from_type(type)
         class_name = @@resource_types[type]
         if class_name.nil?
-          class_name = "#{type.to_s.singularize}_resource".camelize
+          class_name = "#{type.to_s.underscore.singularize}_resource".camelize
           @@resource_types[type] = class_name
         end
         return class_name
@@ -578,19 +614,20 @@ module JSONAPI
       end
 
       def module_path
-        @module_path ||= self.name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').downcase : ''
+        @module_path ||= name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').downcase : ''
       end
 
       def construct_order_options(sort_params)
         return {} unless sort_params
 
-        sort_params.each_with_object({}) { |sort, order_hash|
+        sort_params.each_with_object({}) do |sort, order_hash|
           field = sort[:field] == 'id' ? _primary_key : sort[:field]
           order_hash[field] = sort[:direction]
-        }
+        end
       end
 
       private
+
       def check_reserved_resource_name(type, name)
         if [:ids, :types, :hrefs, :links].include?(type)
           warn "[NAME COLLISION] `#{name}` is a reserved resource name."
@@ -618,63 +655,79 @@ module JSONAPI
 
         attrs.each do |attr|
           check_reserved_association_name(attr)
+          @_associations[attr] = association = klass.new(attr, options)
 
-          @_associations[attr] = klass.new(attr, options)
+          associated_records_method_name = case association
+                                           when JSONAPI::Association::HasOne then "record_for_#{attr}"
+                                           when JSONAPI::Association::HasMany then "records_for_#{attr}"
+                                           end
 
-          foreign_key = @_associations[attr].foreign_key
-
-          define_method foreign_key do
-            @model.method(foreign_key).call
-          end unless method_defined?(foreign_key)
+          foreign_key = association.foreign_key
 
           define_method "#{foreign_key}=" do |value|
             @model.method("#{foreign_key}=").call(value)
           end unless method_defined?("#{foreign_key}=")
 
-          associated_records_method_name = case @_associations[attr]
-          when JSONAPI::Association::HasOne then "record_for_#{attr}"
-          when JSONAPI::Association::HasMany then "records_for_#{attr}"
-          end
-
-          define_method associated_records_method_name do |options={}|
-            records_for(attr, options)
+          define_method associated_records_method_name do |options = {}|
+            relation_name = association.relation_name(options.merge({context: @context}))
+            records_for(relation_name, options)
           end unless method_defined?(associated_records_method_name)
 
-          if @_associations[attr].is_a?(JSONAPI::Association::HasOne)
-            define_method attr do
-              type_name = self.class._associations[attr].type.to_s
-              resource_class = Resource.resource_for(self.class.module_path + type_name)
-              if resource_class
+          if association.is_a?(JSONAPI::Association::HasOne)
+            define_method foreign_key do
+              @model.method(foreign_key).call
+            end unless method_defined?(foreign_key)
+
+            define_method attr do |options = {}|
+              if association.polymorphic?
                 associated_model = public_send(associated_records_method_name)
-                return associated_model ? resource_class.new(associated_model, @context) : nil
+                resource_klass = Resource.resource_for(self.class.module_path + associated_model.class.to_s.underscore) if associated_model
+                return resource_klass.new(associated_model, @context) if resource_klass
+              else
+                resource_klass = association.resource_klass
+                if resource_klass
+                  associated_model = public_send(associated_records_method_name)
+                  return associated_model ? resource_klass.new(associated_model, @context) : nil
+                end
               end
             end unless method_defined?(attr)
-          elsif @_associations[attr].is_a?(JSONAPI::Association::HasMany)
+          elsif association.is_a?(JSONAPI::Association::HasMany)
+            define_method foreign_key do
+              records = public_send(associated_records_method_name)
+              return records.collect do |record|
+                record.send(association.resource_klass._primary_key)
+              end
+            end unless method_defined?(foreign_key)
             define_method attr do |options = {}|
-              type_name = self.class._associations[attr].type.to_s
-              resource_class = Resource.resource_for(self.class.module_path + type_name)
+              resource_klass = association.resource_klass
+              records = public_send(associated_records_method_name)
+
               filters = options.fetch(:filters, {})
+              unless filters.nil? || filters.empty?
+                records = resource_klass.apply_filters(records, filters, options)
+              end
+
               sort_criteria =  options.fetch(:sort_criteria, {})
-              paginator = options[:paginator]
+              unless sort_criteria.nil? || sort_criteria.empty?
+                order_options = self.class.construct_order_options(sort_criteria)
+                records = resource_klass.apply_sort(records, order_options)
+              end
 
-              resources = []
+              paginator = options[:paginator]
+              if paginator
+                records = resource_klass.apply_pagination(records, paginator, order_options)
+              end
 
-              if resource_class
-                records = public_send(associated_records_method_name)
-                records = resource_class.apply_filters(records, filters, options)
-                order_options = self.class.construct_order_options(sort_criteria)
-                records = resource_class.apply_sort(records, order_options)
-                records = resource_class.apply_pagination(records, paginator, order_options)
-                records.each do |record|
-                  resources.push resource_class.new(record, @context)
+              return records.collect do |record|
+                if association.polymorphic?
+                  resource_klass = Resource.resource_for(self.class.module_path + record.class.to_s.underscore)
                 end
+                resource_klass.new(record, @context)
               end
-              return resources
             end unless method_defined?(attr)
           end
         end
       end
     end
-
   end
 end