jsonapi-resources 0.2.0 → 0.3.0.pre1

data/lib/jsonapi/resource.rb

@@ -1,11 +1,9 @@
 require 'jsonapi/configuration'
-require 'jsonapi/resource_for'
 require 'jsonapi/association'
 require 'jsonapi/callbacks'
 
 module JSONAPI
   class Resource
-    include ResourceFor
     include Callbacks
 
     @@resource_types = {}
@@ -101,6 +99,12 @@ module JSONAPI
       self.class.fields
     end
 
+    # Override this on a resource to customize how the associated records
+    # are fetched for a model. Particularly helpful for authoriztion.
+    def records_for(association_name, options = {})
+      model.send association_name
+    end
+
     private
     def save
       run_callbacks :save do
@@ -123,7 +127,7 @@ module JSONAPI
       association = self.class._associations[association_type]
 
       association_key_values.each do |association_key_value|
-        related_resource = self.class.resource_for(association.type).find_by_key(association_key_value, context: @context)
+        related_resource = Resource.resource_for(association.type).find_by_key(association_key_value, context: @context)
 
         # 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
@@ -206,6 +210,15 @@ module JSONAPI
         @@resource_types[base._type] ||= base.name.demodulize
       end
 
+      def resource_for(type)
+        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)"
+        end
+        resource
+      end
+
       attr_accessor :_attributes, :_associations, :_allowed_filters , :_type, :_paginator
 
       def create(context)
@@ -269,13 +282,6 @@ module JSONAPI
         @_allowed_filters.add(attr.to_sym)
       end
 
-      def key(key)
-        # :nocov:
-        warn '[DEPRECATION] `key` is deprecated.  Please use `primary_key` instead.'
-        @_primary_key = key.to_sym
-        # :nocov:
-      end
-
       def primary_key(key)
         @_primary_key = key.to_sym
       end
@@ -359,20 +365,8 @@ module JSONAPI
         self.new(model, context)
       end
 
-      def find_by_keys(keys, options = {})
-        context = options[:context]
-        _models = records(options).where({_primary_key => keys})
-
-        unless _models.length == keys.length
-          key = (keys - _models.pluck(_primary_key).map(&:to_s)).first
-          raise JSONAPI::Exceptions::RecordNotFound.new(key)
-        end
-
-        _models.map { |model| self.new(model, context) }
-      end
-
       # Override this method if you want to customize the relation for
-      # finder methods (find, find_by_key, find_by_keys)
+      # finder methods (find, find_by_key)
       def records(options = {})
         _model_class
       end
@@ -403,7 +397,9 @@ module JSONAPI
 
       # override to allow for key processing and checking
       def verify_key(key, context = nil)
-        return key
+        key && Integer(key)
+      rescue
+        raise JSONAPI::Exceptions::InvalidFieldValue.new(_primary_key, key)
       end
 
       # override to allow for key processing and checking
@@ -453,13 +449,6 @@ module JSONAPI
         @_model_name ||= self.name.demodulize.sub(/Resource$/, '')
       end
 
-      def _key
-        # :nocov:
-        warn '[DEPRECATION] `_key` is deprecated.  Please use `_primary_key` instead.'
-        _primary_key
-        # :nocov:
-      end
-
       def _primary_key
         @_primary_key ||= :id
       end
@@ -489,17 +478,9 @@ module JSONAPI
         @_paginator = paginator
       end
 
-      # :nocov:
-      if RUBY_VERSION >= '2.0'
-        def _model_class
-          @model ||= Object.const_get(_model_name.to_s)
-        end
-      else
-        def _model_class
-          @model ||= _model_name.to_s.safe_constantize
-        end
+      def _model_class
+        @model ||= _model_name.to_s.safe_constantize
       end
-      # :nocov:
 
       def _allowed_filter?(filter)
         _allowed_filters.include?(filter)
@@ -555,26 +536,35 @@ module JSONAPI
             @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)
+          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 = self.class.resource_for(self.class.module_path + type_name)
+              resource_class = Resource.resource_for(self.class.module_path + type_name)
               if resource_class
-                associated_model = @model.send attr
+                associated_model = public_send(associated_records_method_name)
                 return associated_model ? resource_class.new(associated_model, @context) : nil
               end
             end unless method_defined?(attr)
           elsif @_associations[attr].is_a?(JSONAPI::Association::HasMany)
             define_method attr do |options = {}|
               type_name = self.class._associations[attr].type.to_s
-              resource_class = self.class.resource_for(self.class.module_path + type_name)
+              resource_class = Resource.resource_for(self.class.module_path + type_name)
               filters = options.fetch(:filters, {})
               sort_criteria =  options.fetch(:sort_criteria, {})
               paginator = options.fetch(:paginator, nil)
 
               resources = []
               if resource_class
-                records = @model.send attr
+                records = public_send(associated_records_method_name)
                 records = self.class.apply_filters(records, filters)
                 records = self.class.apply_sort(records, self.class.construct_order_options(sort_criteria))
                 records = self.class.apply_pagination(records, paginator)

data/lib/jsonapi/resource_controller.rb

@@ -1,4 +1,3 @@
-require 'jsonapi/resource_for'
 require 'jsonapi/resource_serializer'
 require 'action_controller'
 require 'jsonapi/exceptions'
@@ -11,8 +10,6 @@ require 'csv'
 
 module JSONAPI
   class ResourceController < ActionController::Base
-    include ResourceFor
-
     before_filter :ensure_correct_media_type, only: [:create, :update, :create_association, :update_association]
     before_filter :setup_request
     after_filter :setup_response
@@ -43,15 +40,11 @@ module JSONAPI
                                                    key_formatter: key_formatter,
                                                    route_formatter: route_formatter)
 
-      keys = parse_key_array(params[resource_klass._primary_key])
+      key = resource_klass.verify_key(params[resource_klass._primary_key], context)
 
-      resource_records = if keys.length > 1
-                           resource_klass.find_by_keys(keys, context: context)
-                         else
-                           resource_klass.find_by_key(keys[0], context: context)
-                         end
+      resource_record = resource_klass.find_by_key(key, context: context)
 
-      render json: serializer.serialize_to_hash(resource_records)
+      render json: serializer.serialize_to_hash(resource_record)
     rescue => e
       handle_exceptions(e)
     end
@@ -59,7 +52,7 @@ module JSONAPI
     def show_association
       association_type = params[:association]
 
-      parent_key = params[resource_klass._as_parent_key]
+      parent_key = resource_klass.verify_key(params[resource_klass._as_parent_key], context)
 
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
@@ -73,9 +66,7 @@ module JSONAPI
 
       render json: serializer.serialize_to_links_hash(parent_resource, association)
     rescue => e
-      # :nocov:
       handle_exceptions(e)
-      # :nocov:
     end
 
     def create
@@ -143,17 +134,9 @@ module JSONAPI
     end
 
     private
-    # :nocov:
-    if RUBY_VERSION >= '2.0'
-      def resource_klass
-        @resource_klass ||= Object.const_get resource_klass_name
-      end
-    else
-      def resource_klass
-        @resource_klass ||= resource_klass_name.safe_constantize
-      end
+    def resource_klass
+      @resource_klass ||= resource_klass_name.safe_constantize
     end
-    # :nocov:
 
     def base_url
       @base_url ||= request.protocol + request.host_with_port
@@ -168,9 +151,7 @@ module JSONAPI
         raise JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
       end
     rescue => e
-      # :nocov:
       handle_exceptions(e)
-      # :nocov:
     end
 
     def setup_request
@@ -180,9 +161,7 @@ module JSONAPI
       })
       render_errors(@request.errors) unless @request.errors.empty?
     rescue => e
-      # :nocov:
       handle_exceptions(e)
-      # :nocov:
     end
 
     def setup_response
@@ -191,11 +170,6 @@ module JSONAPI
       end
     end
 
-    def parse_key_array(raw)
-      keys = raw.nil? || raw.empty? ? [] : raw.split(',')
-      resource_klass.verify_keys(keys, context)
-    end
-
     # override to set context
     def context
       {}

data/lib/jsonapi/resource_serializer.rb

@@ -27,28 +27,28 @@ module JSONAPI
     def serialize_to_hash(source)
       is_resource_collection = source.respond_to?(:to_ary)
 
-      @linked_objects = {}
+      @included_objects = {}
 
       requested_associations = parse_includes(@include)
 
       process_primary(source, requested_associations)
 
-      linked_objects = []
+      included_objects = []
       primary_objects = []
-      @linked_objects.each_value do |objects|
+      @included_objects.each_value do |objects|
         objects.each_value do |object|
           if object[:primary]
             primary_objects.push(object[:object_hash])
           else
-            linked_objects.push(object[:object_hash])
+            included_objects.push(object[:object_hash])
           end
         end
       end
 
       primary_hash = {data: is_resource_collection ? primary_objects : primary_objects[0]}
 
-      if linked_objects.size > 0
-        primary_hash[:linked] = linked_objects
+      if included_objects.size > 0
+        primary_hash[:included] = included_objects
       else
         primary_hash
       end
@@ -56,7 +56,19 @@ module JSONAPI
     end
 
     def serialize_to_links_hash(source, requested_association)
-      {data: link_object(source, requested_association, true)}
+      if requested_association.is_a?(JSONAPI::Association::HasOne)
+        data = has_one_linkage(source, requested_association)
+      else
+        data = has_many_linkage(source, requested_association)
+      end
+
+      {
+        links: {
+          self: self_link(source, requested_association),
+          related: related_link(source, requested_association)
+        },
+        data: data
+      }
     end
 
     private
@@ -95,7 +107,7 @@ module JSONAPI
             set_primary(@primary_class_name, id)
           end
 
-          add_linked_object(@primary_class_name, id, object_hash(resource,  requested_associations), true)
+          add_included_object(@primary_class_name, id, object_hash(resource,  requested_associations), true)
         end
       else
         resource = source
@@ -105,7 +117,7 @@ module JSONAPI
         #   set_primary(@primary_class_name, id)
         # end
 
-        add_linked_object(@primary_class_name, id, object_hash(source,  requested_associations), true)
+        add_included_object(@primary_class_name, id, object_hash(source,  requested_associations), true)
       end
     end
 
@@ -185,7 +197,7 @@ module JSONAPI
                 id = resource.id
                 associations_only = already_serialized?(type, id)
                 if include_linkage && !associations_only
-                  add_linked_object(type, id, object_hash(resource, ia[:include_related]))
+                  add_included_object(type, id, object_hash(resource, ia[:include_related]))
                 elsif include_linked_children || associations_only
                   links_hash(resource, ia[:include_related])
                 end
@@ -196,7 +208,7 @@ module JSONAPI
                 id = resource.id
                 associations_only = already_serialized?(type, id)
                 if include_linkage && !associations_only
-                  add_linked_object(type, id, object_hash(resource, ia[:include_related]))
+                  add_included_object(type, id, object_hash(resource, ia[:include_related]))
                 elsif include_linked_children || associations_only
                   links_hash(resource, ia[:include_related])
                 end
@@ -217,36 +229,53 @@ module JSONAPI
 
     def already_serialized?(type, id)
       type = format_key(type)
-      return @linked_objects.key?(type) && @linked_objects[type].key?(id)
+      return @included_objects.key?(type) && @included_objects[type].key?(id)
     end
 
     def format_route(route)
       @route_formatter.format(route.to_s)
     end
 
-    def link_object_has_one(source, association)
-      route = association.name
+    def self_link(source, association)
+      "#{self_href(source)}/links/#{format_route(association.name)}"
+    end
+
+    def related_link(source, association)
+      "#{self_href(source)}/#{format_route(association.name)}"
+    end
+
+    def has_one_linkage(source, association)
+      linkage = {}
+      linkage_id = foreign_key_value(source, association)
+      if linkage_id
+        linkage[:type] = format_route(association.type)
+        linkage[:id] = linkage_id
+      end
+      linkage
+    end
+
+    def has_many_linkage(source, association)
+      linkage = []
+      linkage_ids = foreign_key_value(source, association)
+      linkage_ids.each do |linkage_id|
+        linkage.append({type: format_route(association.type), id: linkage_id})
+      end
+      linkage
+    end
 
+    def link_object_has_one(source, association)
       link_object_hash = {}
-      link_object_hash[:self] = "#{self_href(source)}/links/#{format_route(route)}"
-      link_object_hash[:resource] = "#{self_href(source)}/#{format_route(route)}"
-      # ToDo: Get correct formatting figured out
-      link_object_hash[:type] = format_route(association.type)
-      link_object_hash[:id] = foreign_key_value(source, association)
+      link_object_hash[:self] = self_link(source, association)
+      link_object_hash[:related] = related_link(source, association)
+      link_object_hash[:linkage] = has_one_linkage(source, association)
       link_object_hash
     end
 
     def link_object_has_many(source, association, include_linkage)
-      route = association.name
-
       link_object_hash = {}
-      link_object_hash[:self] = "#{self_href(source)}/links/#{format_route(route)}"
-      link_object_hash[:resource] = "#{self_href(source)}/#{format_route(route)}"
-      if include_linkage
-        # ToDo: Get correct formatting figured out
-        link_object_hash[:type] = format_route(association.type)
-        link_object_hash[:ids] = foreign_key_value(source, association)
-      end
+      link_object_hash[:self] = self_link(source, association)
+      link_object_hash[:related] = related_link(source, association)
+      link_object_hash[:linkage] = has_many_linkage(source, association) if include_linkage
       link_object_hash
     end
 
@@ -273,15 +302,15 @@ module JSONAPI
     # Sets that an object should be included in the primary document of the response.
     def set_primary(type, id)
       type = format_key(type)
-      @linked_objects[type][id][:primary] = true
+      @included_objects[type][id][:primary] = true
     end
 
     # Collects the hashes for all objects processed by the serializer
-    def add_linked_object(type, id, object_hash, primary = false)
+    def add_included_object(type, id, object_hash, primary = false)
       type = format_key(type)
 
-      unless @linked_objects.key?(type)
-        @linked_objects[type] = {}
+      unless @included_objects.key?(type)
+        @included_objects[type] = {}
       end
 
       if already_serialized?(type, id)
@@ -289,7 +318,7 @@ module JSONAPI
           set_primary(type, id)
         end
       else
-        @linked_objects[type].store(id, {primary: primary, object_hash: object_hash})
+        @included_objects[type].store(id, {primary: primary, object_hash: object_hash})
       end
     end