jsonapi-resources 0.2.0 → 0.3.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7639392d6acfd2092e36563bebd32e791b7df37a
-  data.tar.gz: 6c7e794b2646d60214746515810d9648566699e8
+  metadata.gz: 7979f6e3a6f09ec2999fb78b2e0a06aa8f6f8be4
+  data.tar.gz: 6819f84c905130eaf614059393c59e55de8c457c
 SHA512:
-  metadata.gz: 0d53447be085f1ce717782ad9238116e30968e0380fe6e5612e3b5b1a680978285e363904c9c4a96b5ac115bcec8addad959851cd4dfeb58244ab704215eba1c
-  data.tar.gz: 725dd95e1409afd23a1f22a6f7399a8fcc402734adc5da297cc019f65186c2777b3bb8c2aacf7955e1dcd1cc89af1fced6702898222ca2b3746be2e4800bbebc
+  metadata.gz: 7389937f7df1ce1ece2ee0a481e626c7c8385cdddda73c12ec7625192eea77d27c4daa9d3bc73a5a10a0eb6aeab8fa4944459b52d0e8fefa8d36469f84dcf230
+  data.tar.gz: 0e3c2330066fc109530a627b9d5126e9cb60365c7dd5727230df9f9f9de27b3c9089637de1d447677774d76784d9816107d6d06df3a411d67fc779d481c2c329

data/.gitignore

@@ -17,4 +17,6 @@ test/tmp
 test/version_tmp
 tmp
 coverage
-test/log
+test/log
+test_db
+test_db-journal

data/.travis.yml

@@ -1,6 +1,9 @@
 language: ruby
+env:
+  - "RAILS_VERSION=4.0"
+  - "RAILS_VERSION=4.1"
+  - "RAILS_VERSION=4.2"
 rvm:
-  - 1.9.3
-  - 2.0.0
+  - 2.0
   - 2.1
   - 2.2

data/Gemfile

@@ -10,10 +10,12 @@ platforms :jruby do
   gem 'activerecord-jdbcsqlite3-adapter'
 end
 
-version = ENV['RAILS_VERSION'] || '4.0.4'
+version = ENV['RAILS_VERSION'] || 'default'
 rails = case version
         when 'master'
           {:github => 'rails/rails'}
+        when 'default'
+            '>= 4.2'
         else
           "~> #{version}"
         end

data/README.md

@@ -166,6 +166,7 @@ The system will lookup a value formatter named `DateWithTimezoneValueFormatter`
 #### Primary Key
 
 Resources are always represented using a key of `id`. If the underlying model does not use `id` as the primary key you can use the `primary_key` method to tell the resource which field on the model to use as the primary key. Note: this doesn't have to be the actual primary key of the model. For example you may wish to use integers internally and a different scheme publicly.
+By default only integer values are allowed for primary key. To change this behavior you can override `verify_key` class method:
 
 ```ruby
 class CurrencyResource < JSONAPI::Resource
@@ -173,8 +174,11 @@ class CurrencyResource < JSONAPI::Resource
   attributes :code, :name
 
   has_many :expense_entries
-end
 
+  def self.verify_key(key, context = nil)
+    key && String(key)
+  end
+end
 ```
 
 #### Model Name
@@ -260,11 +264,11 @@ end
 
 ##### Finders
 
-Basic finding by filters is supported by resources. This is implemented in the `find`, `find_by_key` and `find_by_keys` finder methods. Currently this is implemented for `ActiveRecord` based resources. The finder methods rely on the `records` method to get an `Arel` relation. It is therefore possible to override `records` to affect the three find related methods.
+Basic finding by filters is supported by resources. This is implemented in the `find` and `find_by_key` finder methods. Currently this is implemented for `ActiveRecord` based resources. The finder methods rely on the `records` method to get an `Arel` relation. It is therefore possible to override `records` to affect the three find related methods.
 
 ###### Customizing base records for finder methods
 
-If you need to change the base records on which `find`, `find_by_key` and `find_by_keys` operate, you can override the `records` method on the resource class.
+If you need to change the base records on which `find` and `find_by_key` operate, you can override the `records` method on the resource class.
 
 For example to allow a user to only retrieve his own posts you can do the following:
 
@@ -279,6 +283,41 @@ class PostResource < JSONAPI::Resource
 end
 ```
 
+When you create a relationship, a method is created to fetch record(s) for that relationship. This method calls `records_for(association_name)` by default.
+
+```ruby
+class PostResource < JSONAPI::Resource
+  has_one :author
+  has_many :comments
+
+  # def record_for_author(options = {})
+  #   records_for("author", options)
+  # end
+
+  # def records_for_comments(options = {})
+  #   records_for("comments", options)
+  # end
+end
+
+```
+
+For example, you may want raise an error if the user is not authorized to view the associated records.
+
+```ruby
+class BaseResource < JSONAPI::Resource
+  def records_for(association_name, options={})
+    context = options[:context]
+    records = model.public_send(association_name)
+
+    unless context.current_user.can_view?(records)
+      raise NotAuthorizedError
+    end
+
+    records
+  end
+end
+```
+
 ###### Applying Filters
 
 The `apply_filter` method is called to apply each filter to the `Arel` relation. You may override this method to gain control over how the filters are applied to the `Arel` relation.
@@ -286,7 +325,7 @@ The `apply_filter` method is called to apply each filter to the `Arel` relation.
 This example shows how you can implement different approaches for different filters.
 
 ```ruby
-def apply_filter(records, filter, value)
+def self.apply_filter(records, filter, value)
   case filter
     when :visibility
       records.where('users.publicly_visible = ?', value == :public)
@@ -307,7 +346,7 @@ end
 
 ###### Override finder methods
 
-Finally if you have more complex requirements for finding you can override the `find`, `find_by_key` and `find_by_keys` methods on the resource class.
+Finally if you have more complex requirements for finding you can override the `find` and `find_by_key` methods on the resource class.
 
 Here's an example that defers the `find` operation to a `current_user` set on the `context` option:
 
@@ -367,15 +406,15 @@ end
 
 ##### Paginator Configuration
 
-The default paginator, which will be used for all resources, is set using `JSONAPI.configure`. For example:
+The default paginator, which will be used for all resources, is set using `JSONAPI.configure`. For example, in your `config/initializers/jsonapi_resources.rb`:
 
 ```ruby
 JSONAPI.configure do |config|
   # built in paginators are :none, :offset, :cursor, :paged
-  self.default_paginator = :offset
+  config.default_paginator = :offset
 
-  self.default_page_size = 10
-  self.maximum_page_size = 20
+  config.default_page_size = 10
+  config.maximum_page_size = 20
 end
 ```
 
@@ -630,7 +669,7 @@ The `serialize_to_hash` method also takes some optional parameters:
 
 An array of resources. Nested resources can be specified with dot notation.
 
-  *Purpose*: determines which objects will be side loaded with the source objects in a linked section
+  *Purpose*: determines which objects will be side loaded with the source objects in an `included` section
 
   *Example*: ```include: ['comments','author','comments.tags','author.posts']```
 
@@ -828,9 +867,9 @@ This way all DateTime values will be formatted to display in the specified timez
 
 #### Key Format
 
-JSONAPI is agnostic on the format of the keys used in the responses. By default JR uses underscored keys which match the attribute names used by Rails models.  This can be changed by specifying a different key formatter.
+By default JR uses dasherized keys as per the [JSON API naming recommendations](http://jsonapi.org/recommendations/#naming).  This can be changed by specifying a different key formatter.
 
-For example to use camel cased keys with an initial lowercase character (JSON's default) create an initializer and add the following:
+For example, to use camel cased keys with an initial lowercase character (JSON's default) create an initializer and add the following:
 
 ```
 JSONAPI.configure do |config|
@@ -839,7 +878,7 @@ JSONAPI.configure do |config|
 end
 ```
 
-This will cause the serializer to use the `CamelizedKeyFormatter`. Besides `UnderscoredKeyFormatter` and `CamelizedKeyFormatter` JR defines the `DasherizedKeyFormatter`. You can also create your own `KeyFormatter`, for example:
+This will cause the serializer to use the `CamelizedKeyFormatter`. You can also create your own `KeyFormatter`, for example:
 
 ```ruby
 class UpperCamelizedKeyFormatter < JSONAPI::KeyFormatter

data/jsonapi-resources.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = '>= 2.0'
 
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'rake'

data/lib/jsonapi-resources.rb

@@ -1,4 +1,5 @@
 require 'jsonapi/resource'
+require 'jsonapi/resource_controller'
 require 'jsonapi/resources/version'
 require 'jsonapi/configuration'
 require 'jsonapi/paginator'

data/lib/jsonapi/association.rb

@@ -6,15 +6,7 @@ module JSONAPI
       @name                = name.to_s
       @options             = options
       @acts_as_set         = options.fetch(:acts_as_set, false) == true
-      @key                 = options[:key] ? options[:key].to_sym : nil
-
-      if @key.nil?
-        @foreign_key  = options[:foreign_key ] ? options[:foreign_key ].to_sym : nil
-      else
-        # :nocov:
-        warn '[DEPRECATION] `key` is deprecated in associations.  Please use `foreign_key` instead.'
-        # :nocov:
-      end
+      @foreign_key         = options[:foreign_key ] ? options[:foreign_key ].to_sym : nil
     end
 
     def primary_key

data/lib/jsonapi/error_codes.rb

@@ -18,6 +18,7 @@ module JSONAPI
   INVALID_PAGE_OBJECT = 117
   INVALID_PAGE_VALUE = 118
   INVALID_SORT_FORMAT = 119
+  INVALID_FIELD_FORMAT = 120
   RECORD_NOT_FOUND = 404
   UNSUPPORTED_MEDIA_TYPE = 415
   LOCKED = 423

data/lib/jsonapi/exceptions.rb

@@ -102,17 +102,21 @@ module JSONAPI
       end
     end
 
-    class InvalidLinksObject < Error
-      attr_accessor :value
-      def initialize(value)
-        @value = value
+    class InvalidFieldFormat < Error
+      def errors
+        [JSONAPI::Error.new(code: JSONAPI::INVALID_FIELD_FORMAT,
+                            status: :bad_request,
+                            title: 'Invalid field format',
+                            detail: 'Fields must specify a type.')]
       end
+    end
 
+    class InvalidLinksObject < Error
       def errors
         [JSONAPI::Error.new(code: JSONAPI::INVALID_LINKS_OBJECT,
                             status: :bad_request,
                             title: 'Invalid Links Object',
-                            detail: "#{value} is not a valid Links Object.")]
+                            detail: 'Data is not a valid Links Object.')]
       end
     end
 

data/lib/jsonapi/formatter.rb

@@ -9,19 +9,10 @@ module JSONAPI
         arg
       end
 
-      # :nocov:
-      if RUBY_VERSION >= '2.0'
-        def formatter_for(format)
-          formatter_class_name = "#{format.to_s.camelize}Formatter"
-          Object.const_get formatter_class_name if formatter_class_name
-        end
-      else
-        def formatter_for(format)
-          formatter_class_name = "#{format.to_s.camelize}Formatter"
-          formatter_class_name.safe_constantize if formatter_class_name
-        end
+      def formatter_for(format)
+        formatter_class_name = "#{format.to_s.camelize}Formatter"
+        formatter_class_name.safe_constantize if formatter_class_name
       end
-      # :nocov:
     end
   end
 
@@ -32,7 +23,7 @@ module JSONAPI
       end
 
       def unformat(formatted_key)
-        super.to_sym
+        super
       end
     end
   end
@@ -44,7 +35,7 @@ module JSONAPI
       end
 
       def unformat(formatted_route)
-        super.to_sym
+        super
       end
     end
   end
@@ -77,7 +68,7 @@ class CamelizedKeyFormatter < JSONAPI::KeyFormatter
     end
 
     def unformat(formatted_key)
-      formatted_key.to_s.underscore.to_sym
+      formatted_key.to_s.underscore
     end
   end
 end
@@ -89,7 +80,7 @@ class DasherizedKeyFormatter < JSONAPI::KeyFormatter
     end
 
     def unformat(formatted_key)
-      formatted_key.to_s.underscore.to_sym
+      formatted_key.to_s.underscore
     end
   end
 end
@@ -121,7 +112,7 @@ class CamelizedRouteFormatter < JSONAPI::RouteFormatter
     end
 
     def unformat(formatted_route)
-      formatted_route.to_s.underscore.to_sym
+      formatted_route.to_s.underscore
     end
   end
 end
@@ -133,7 +124,7 @@ class DasherizedRouteFormatter < JSONAPI::RouteFormatter
     end
 
     def unformat(formatted_route)
-      formatted_route.to_s.underscore.to_sym
+      formatted_route.to_s.underscore
     end
   end
 end

data/lib/jsonapi/paginator.rb

@@ -4,25 +4,14 @@ module JSONAPI
     end
 
     def apply(relation)
-      # :nocov:
-      relation
-      # :nocov:
+      # relation
     end
 
     class << self
-      # :nocov:
-      if RUBY_VERSION >= '2.0'
-        def paginator_for(paginator)
-          paginator_class_name = "#{paginator.to_s.camelize}Paginator"
-          Object.const_get(paginator_class_name) if paginator_class_name
-        end
-      else
-        def paginator_for(paginator)
-          paginator_class_name = "#{paginator.to_s.camelize}Paginator"
-          paginator_class_name.safe_constantize if paginator_class_name
-        end
+      def paginator_for(paginator)
+        paginator_class_name = "#{paginator.to_s.camelize}Paginator"
+        paginator_class_name.safe_constantize if paginator_class_name
       end
-      # :nocov:
     end
   end
 end

data/lib/jsonapi/request.rb

@@ -1,11 +1,8 @@
-require 'jsonapi/resource_for'
 require 'jsonapi/operation'
 require 'jsonapi/paginator'
 
 module JSONAPI
   class Request
-    include ResourceFor
-
     attr_accessor :fields, :include, :filters, :sort_criteria, :errors, :operations,
                   :resource_klass, :context, :paginator, :source_klass, :source_id
 
@@ -25,7 +22,7 @@ module JSONAPI
     end
 
     def setup(params)
-      @resource_klass ||= self.class.resource_for(params[:controller]) if params[:controller]
+      @resource_klass ||= Resource.resource_for(params[:controller]) if params[:controller]
 
       unless params.nil?
         case params[:action]
@@ -36,8 +33,8 @@ module JSONAPI
             parse_sort_criteria(params[:sort])
             parse_pagination(params[:page])
           when 'get_related_resource', 'get_related_resources'
-            @source_klass = self.class.resource_for(params.require(:source))
-            @source_id = params.require(@source_klass._as_parent_key)
+            @source_klass = Resource.resource_for(params.require(:source))
+            @source_id = @source_klass.verify_key(params.require(@source_klass._as_parent_key), @context)
             parse_fields(params[:fields])
             parse_include(params[:include])
             parse_filters(params[:filter])
@@ -55,7 +52,7 @@ module JSONAPI
                                             params.require(:association),
                                             params.require(@resource_klass._as_parent_key))
           when 'update_association'
-            parse_update_association_operation(params.require(:data),
+            parse_update_association_operation(params.fetch(:data),
                                                params.require(:association),
                                                params.require(@resource_klass._as_parent_key))
           when 'update'
@@ -85,15 +82,13 @@ module JSONAPI
       extracted_fields = {}
 
       # Extract the fields for each type from the fields parameters
-      if fields.is_a?(String)
-        resource_fields = fields.split(',') unless fields.empty?
-        type = @resource_klass._type
-        extracted_fields[type] = resource_fields
-      elsif fields.is_a?(ActionController::Parameters)
+      if fields.is_a?(ActionController::Parameters)
         fields.each do |field, value|
           resource_fields = value.split(',') unless value.nil? || value.empty?
           extracted_fields[field] = resource_fields
         end
+      else
+        raise JSONAPI::Exceptions::InvalidFieldFormat.new
       end
 
       # Validate the fields
@@ -101,10 +96,16 @@ module JSONAPI
         underscored_type = unformat_key(type)
         extracted_fields[type] = []
         begin
-          type_resource = self.class.resource_for(@resource_klass.module_path + underscored_type.to_s)
+          if type != format_key(type)
+            raise JSONAPI::Exceptions::InvalidResource.new(type)
+          end
+          type_resource = Resource.resource_for(@resource_klass.module_path + underscored_type.to_s)
         rescue NameError
           @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
+        rescue JSONAPI::Exceptions::InvalidResource => e
+        @errors.concat(e.errors)
         end
+
         if type_resource.nil? || !(@resource_klass._type == underscored_type ||
           @resource_klass._has_association?(underscored_type))
           @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
@@ -131,7 +132,7 @@ module JSONAPI
       association_name = unformat_key(include_parts.first)
 
       association = resource_klass._association(association_name)
-      if association
+      if association && format_key(association_name) == include_parts.first
         unless include_parts.last.empty?
           check_include(Resource.resource_for(@resource_klass.module_path + association.class_name.to_s), include_parts.last.partition('.'))
         end
@@ -158,7 +159,7 @@ module JSONAPI
       return unless filters
       @filters = {}
       filters.each do |key, value|
-        filter = unformat_key(key).to_sym
+        filter = unformat_key(key)
         if @resource_klass._allowed_filter?(filter)
           @filters[filter] = value
         else
@@ -214,7 +215,7 @@ module JSONAPI
 
     def verify_and_remove_type(params)
       #remove type and verify it matches the resource
-      if params[:type] == @resource_klass._type.to_s
+      if unformat_key(params[:type]) == @resource_klass._type
         params.delete(:type)
       else
         if params[:type].nil?
@@ -235,7 +236,7 @@ module JSONAPI
       end
 
       if !raw.is_a?(Hash) || raw.length != 2 || !(raw.has_key?('type') && raw.has_key?('id'))
-        raise JSONAPI::Exceptions::InvalidLinksObject.new(raw)
+        raise JSONAPI::Exceptions::InvalidLinksObject.new
       end
 
       {
@@ -246,23 +247,18 @@ module JSONAPI
 
     def parse_has_many_links_object(raw)
       if raw.nil?
-        raise JSONAPI::Exceptions::InvalidLinksObject.new(raw)
+        raise JSONAPI::Exceptions::InvalidLinksObject.new
       end
 
       links_object = {}
-      if raw.is_a?(Hash)
-        if raw.length != 2 || !(raw.has_key?('type') && raw.has_key?('ids')) || !(raw['ids'].is_a?(Array))
-          raise JSONAPI::Exceptions::InvalidLinksObject.new(raw)
-        end
-        links_object[raw['type']] = raw['ids']
-      elsif raw.is_a?(Array)
+      if raw.is_a?(Array)
         raw.each do |link|
           link_object = parse_has_one_links_object(link)
           links_object[link_object[:type]] ||= []
           links_object[link_object[:type]].push(link_object[:id])
         end
       else
-        raise JSONAPI::Exceptions::InvalidLinksObject.new(raw)
+        raise JSONAPI::Exceptions::InvalidLinksObject.new
       end
       links_object
     end
@@ -291,7 +287,7 @@ module JSONAPI
               end
 
               unless links_object[:id].nil?
-                association_resource = @resource_klass.resource_for(@resource_klass.module_path + links_object[:type])
+                association_resource = Resource.resource_for(@resource_klass.module_path + links_object[:type])
                 checked_has_one_associations[param] = association_resource.verify_key(links_object[:id], @context)
               else
                 checked_has_one_associations[param] = nil
@@ -311,14 +307,10 @@ module JSONAPI
                 end
 
                 links_object.each_pair do |type, keys|
-                  association_resource = @resource_klass.resource_for(@resource_klass.module_path + type)
+                  association_resource = Resource.resource_for(@resource_klass.module_path + type)
                   checked_has_many_associations[param] = association_resource.verify_keys(keys, @context)
                 end
               end
-            else
-              # :nocov:
-              raise JSONAPI::Exceptions::InvalidLinksObject.new(key)
-              # :nocov:
             end
           end
         else
@@ -358,23 +350,14 @@ module JSONAPI
       association = resource_klass._association(association_type)
 
       if association.is_a?(JSONAPI::Association::HasMany)
-        ids = data.require(:ids)
-        type = data.require(:type)
-
-        object_params = {links: {association.name => {'type' => type, 'ids' => ids}}}
+        object_params = {links: {association.name => data}}
         verified_param_set = parse_params(object_params, @resource_klass.updateable_fields(@context))
 
         @operations.push JSONAPI::CreateHasManyAssociationOperation.new(resource_klass,
                                                                         parent_key,
                                                                         association_type,
                                                                         verified_param_set[:has_many].values[0])
-      else
-        # :nocov:
-        @errors.concat(JSONAPI::Exceptions::InvalidLinksObject.new(:data).errors)
-        # :nocov:
       end
-    rescue ActionController::ParameterMissing => e
-      @errors.concat(JSONAPI::Exceptions::ParameterMissing.new(e.param).errors)
     end
 
     def parse_update_association_operation(data, association_type, parent_key)
@@ -484,7 +467,8 @@ module JSONAPI
     end
 
     def unformat_key(key)
-      @key_formatter.unformat(key)
+      unformatted_key = @key_formatter.unformat(key)
+      unformatted_key.nil? ? nil : unformatted_key.to_sym
     end
   end
 end