jsonapi-resources 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab4c4a0d0d8f176e2085aee265a0d0678876c8bd
-  data.tar.gz: 04ea25473f89a0bf77df0778b2ebaa7d4dd3aa8d
+  metadata.gz: 61e3e8cacf54569eb7d57771d08cdd4861a84a22
+  data.tar.gz: 25ccc4dc6996b991af26ebc7598129615ee14b4c
 SHA512:
-  metadata.gz: b19b8f700405d1caf6d676a1d984d8d2e0a82aa3d0df31b140d26484f318e74fc94311b4744e40d16ca7bf900a64a27a86351fe588bdee413569da5bbc299c63
-  data.tar.gz: 09b9a7ac8901f2b3c6ff218b8680c8cc313d806cfbd472989623f94871d95466375b6929cbfb2d48105799598a2fdeeee67fd27915fc054e1f53ea191a469d55
+  metadata.gz: 20e94f28d19e31142b2f80c562356a87d17f6d49df68918b4ff9be66a4528b1f734b86a0f98b25fafa566d4c2e3565d08f9cca6ec34878c32b8e40d3e580f029
+  data.tar.gz: 52bcc55a0d1200315129584fb978c75cbcd67bdcebb546cb8a62d137cc4d21f95cf9b1b938303a2dbbe603bb785f265d4f3d2b0b7d6c25746a717de40d5629fe

data/Gemfile

@@ -11,12 +11,13 @@ platforms :jruby do
 end
 
 version = ENV['RAILS_VERSION'] || 'default'
-rails = case version
-        when 'master'
-          { github: 'rails/rails' }
-        when 'default'
-          '>= 4.2'
-        else
-          "~> #{version}"
-        end
-gem 'rails', rails
+
+case version
+when 'master'
+  gem 'rails', { git: 'https://github.com/rails/rails.git' }
+  gem 'arel', { git: 'https://github.com/rails/arel.git' }
+when 'default'
+  gem 'rails', '>= 4.2'
+else
+  gem 'rails', "~> #{version}"
+end

data/README.md

@@ -9,6 +9,30 @@ of your resources, including their attributes and relationships, to make your se
 JR is designed to work with Rails 4.0+, and provides custom routes, controllers, and serializers. JR's resources may be
 backed by ActiveRecord models or by custom objects.
 
+## Table of Contents
+
+* [Demo App] (#demo-app)
+* [Client Libraries] (#client-libraries)
+* [Installation] (#installation)
+* [Usage] (#usage)
+  * [Resources] (#resources)
+    * [JSONAPI::Resource] (#jsonapiresource)
+    * [Attributes] (#attributes)
+    * [Primary Key] (#primary-key)
+    * [Model Name] (#model-name)
+    * [Relationships] (#relationships)
+    * [Filters] (#filters)
+    * [Pagination] (#pagination)
+    * [Included relationships (side-loading resources)] (#included-relationships-side-loading-resources)
+    * [Callbacks] (#callbacks)
+  * [Controllers] (#controllers)
+    * [Namespaces] (#namespaces)
+    * [Error Codes] (#error-codes)
+  * [Serializer] (#serializer)
+* [Configuration] (#configuration)
+* [Contributing] (#contributing)
+* [License] (#license)
+
 ## Demo App
 
 We have a simple demo app, called [Peeps](https://github.com/cerebris/peeps), available to show how JR is used.
@@ -56,12 +80,12 @@ end
 
 A jsonapi-resource generator is avaliable
 ```
-rails generate jsonapi:resource contact 
+rails generate jsonapi:resource contact
 ```
 
 ##### Abstract Resources
 
-Resources that are not backed by a model (purely used as base classes for other resources) should be declared as 
+Resources that are not backed by a model (purely used as base classes for other resources) should be declared as
 abstract.
 
 Because abstract resources do not expect to be backed by a model, they won't attempt to discover the model class
@@ -70,7 +94,7 @@ or any of its relationships.
 ```ruby
 class BaseResource < JSONAPI::Resource
   abstract
-  
+
   has_one :creator
 end
 
@@ -207,19 +231,36 @@ If the underlying model does not use `id` as the primary key _and_ does not supp
 must use the `primary_key` method to tell the resource which field on the model to use as the primary key. **Note:**
 this _must_ be the actual primary key of the model.
 
-By default only integer values are allowed for primary key. To change this behavior you can override
-`verify_key` class method:
+By default only integer values are allowed for primary key. To change this behavior you can set the `resource_key_type`
+configuration option:
 
 ```ruby
-class CurrencyResource < JSONAPI::Resource
-  primary_key :code
-  attributes :code, :name
+JSONAPI.configure do |config|
+  # Allowed values are :integer(default), :uuid, :string, or a proc
+  config.resource_key_type = :uuid
+end
+```
 
-  has_many :expense_entries
+##### Override key type on a resource
 
-  def self.verify_key(key, context = nil)
-    key && String(key)
-  end
+You can override the default resource key type on a per-resource basis by calling `key_type` in the resource class,
+with the same allowed values as the `resource_key_type` configuration option.
+
+```ruby
+class ContactResource < JSONAPI::Resource
+  attribute :id
+  attributes :name_first, :name_last, :email, :twitter
+  key_type :uuid
+end
+```
+
+##### Custom resource key validators
+
+If you need more control over the key, you can override the #verify_key method on your resource, or set a lambda that accepts key and context arguments in `config/initializers/jsonapi_resources.rb`:
+
+```ruby
+JSONAPI.configure do |config|
+  config.resource_key_type = -> (key, context) { key && String(key) }
 end
 ```
 
@@ -427,7 +468,8 @@ end
 
 ```
 
-For example, you may want raise an error if the user is not authorized to view the related records.
+For example, you may want raise an error if the user is not authorized to view the related records. See the next
+section for additional details on raising errors.
 
 ```ruby
 class BaseResource < JSONAPI::Resource
@@ -444,6 +486,42 @@ class BaseResource < JSONAPI::Resource
 end
 ```
 
+
+###### Raising Errors
+
+Inside the finder methods (like `records_for`) or inside of resource callbacks
+(like `before_save`) you can `raise` an error to halt processing. JSONAPI::Resources
+has some built in errors that will return appropriate error codes. By
+default any other error that you raise will return a `500` status code
+for a general internal server error.
+
+To return useful error codes that represent application errors you
+should set the `exception_class_whitelist` config varible, and then you
+should use the Rails `rescue_from` macro to render a status code.
+
+For example, this config setting allows the `NotAuthorizedError` to bubble up out of
+JSONAPI::Resources and into your application.
+
+```ruby
+# config/initializer/jsonapi-resources.rb
+JSONAPI.configure do |config|
+  config.exception_class_whitelist = [NotAuthorizedError]
+end
+```
+
+Handling the error and rendering the appropriate code is now the resonsiblity of the
+application and could be handled like this:
+
+```ruby
+class ApiController < ApplicationController
+  rescue_from NotAuthorizedError, with: :reject_forbidden_request
+  def reject_forbidden_request
+    render json: {error: 'Forbidden'}, :status => 403
+  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
@@ -571,6 +649,67 @@ end
 
 To disable pagination in a resource, specify `:none` for `paginator`.
 
+#### Included relationships (side-loading resources)
+
+JR supports [request include params](http://jsonapi.org/format/#fetching-includes) out of the box, for side loading related resources.
+
+Here's an example from the spec:
+
+```
+GET /articles/1?include=comments HTTP/1.1
+Accept: application/vnd.api+json
+```
+
+Will get you the following payload by default:
+
+```
+{
+  "data": {
+    "type": "articles",
+    "id": "1",
+    "attributes": {
+      "title": "JSON API paints my bikeshed!"
+    },
+    "links": {
+      "self": "http://example.com/articles/1"
+    },
+    "relationships": {
+      "comments": {
+        "links": {
+          "self": "http://example.com/articles/1/relationships/comments",
+          "related": "http://example.com/articles/1/comments"
+        },
+        "data": [
+          { "type": "comments", "id": "5" },
+          { "type": "comments", "id": "12" }
+        ]
+      }
+    }
+  },
+  "included": [{
+    "type": "comments",
+    "id": "5",
+    "attributes": {
+      "body": "First!"
+    },
+    "links": {
+      "self": "http://example.com/comments/5"
+    }
+  }, {
+    "type": "comments",
+    "id": "12",
+    "attributes": {
+      "body": "I like XML better"
+    },
+    "links": {
+      "self": "http://example.com/comments/12"
+    }
+  }]
+}
+```
+
+You can also pass an `include` option to [Serializer#serialize_to_hash](#include) if you want to define this inline.
+
 #### Callbacks
 
 `ActiveSupport::Callbacks` is used to provide callback functionality, so the behavior is very similar to what you may be
@@ -845,7 +984,7 @@ example:
 
 ```ruby
 JSONAPI.configure do |config|
-  config.use_text_errors = :true
+  config.use_text_errors = true
 end
 ```
 
@@ -1277,6 +1416,9 @@ JSONAPI.configure do |config|
   #:basic, :active_record, or custom
   config.operations_processor = :active_record
 
+  #:integer, :uuid, :string, or custom (provide a proc)
+  config.resource_key_type = :integer
+
   # optional request features
   config.allow_include = true
   config.allow_sort = true

data/lib/generators/jsonapi/resource_generator.rb

@@ -6,7 +6,7 @@ module Jsonapi
       template_file = File.join(
         'app/resources',
         class_path,
-        "#{file_name}_resource.rb"
+        "#{file_name.singularize}_resource.rb"
       )
       template 'jsonapi_resource.rb', template_file
     end

data/lib/generators/jsonapi/templates/jsonapi_resource.rb

@@ -1,4 +1,4 @@
 <% module_namespacing do -%>
-class <%= class_name %>Resource < JSONAPI::Resource
+class <%= class_name.singularize %>Resource < JSONAPI::Resource
 end
 <% end -%>

data/lib/jsonapi/configuration.rb

@@ -5,6 +5,7 @@ require 'jsonapi/active_record_operations_processor'
 module JSONAPI
   class Configuration
     attr_reader :json_key_format,
+                :resource_key_type,
                 :key_formatter,
                 :route_format,
                 :route_formatter,
@@ -34,6 +35,9 @@ module JSONAPI
       #:basic, :active_record, or custom
       self.operations_processor = :active_record
 
+      #:integer, :uuid, :string, or custom (provide a proc)
+      self.resource_key_type = :integer
+
       # optional request features
       self.allow_include = true
       self.allow_sort = true
@@ -77,6 +81,10 @@ module JSONAPI
       @key_formatter = JSONAPI::Formatter.formatter_for(format)
     end
 
+    def resource_key_type=(key_type)
+      @resource_key_type = key_type
+    end
+
     def route_format=(format)
       @route_format = format
       @route_formatter = JSONAPI::Formatter.formatter_for(format)

data/lib/jsonapi/error.rb

@@ -14,7 +14,8 @@ module JSONAPI
                         end
       @source         = options[:source]
       @links          = options[:links]
-      @status         = options[:status]
+
+      @status         = Rack::Utils::SYMBOL_TO_STATUS_CODE[options[:status]].to_s
     end
   end
 

data/lib/jsonapi/exceptions.rb

@@ -11,7 +11,7 @@ module JSONAPI
 
       def errors
         [JSONAPI::Error.new(code: JSONAPI::INTERNAL_SERVER_ERROR,
-                            status: 500,
+                            status: :internal_server_error,
                             title: 'Internal Server Error',
                             detail: 'Internal Server Error')]
       end

data/lib/jsonapi/operation.rb

@@ -158,7 +158,7 @@ module JSONAPI
     end
 
     def records
-      related_resource_records = source_resource.public_send(@relationship_type)
+      related_resource_records = source_resource.public_send("records_for_" + @relationship_type)
       @resource_klass.filter_records(@filters, @options, related_resource_records)
     end
 

data/lib/jsonapi/relationship.rb

@@ -24,7 +24,7 @@ module JSONAPI
       @resource_klass ||= Resource.resource_for(@module_path + @class_name)
     end
 
-    def relation_name(options = {})
+    def relation_name(options)
       case @relation_name
         when Symbol
           # :nocov:

data/lib/jsonapi/request.rb

@@ -406,55 +406,12 @@ module JSONAPI
           value.each do |link_key, link_value|
             param = unformat_key(link_key)
             relationship = @resource_klass._relationship(param)
-            if relationship.is_a?(JSONAPI::Relationship::ToOne)
-              if link_value.nil?
-                linkage = nil
-              else
-                linkage = link_value[:data]
-              end
-
-              links_object = parse_to_one_links_object(linkage)
-              if !relationship.polymorphic? && links_object[:type] && (links_object[:type].to_s != relationship.type.to_s)
-                fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
-              end
 
-              unless links_object[:id].nil?
-                relationship_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
-                relationship_id = relationship_resource.verify_key(links_object[:id], @context)
-                if relationship.polymorphic?
-                  checked_to_one_relationships[param] = { id: relationship_id, type: unformat_key(links_object[:type].to_s) }
-                else
-                  checked_to_one_relationships[param] = relationship_id
-                end
-              else
-                checked_to_one_relationships[param] = nil
-              end
+            if relationship.is_a?(JSONAPI::Relationship::ToOne)
+              checked_to_one_relationships[param] = parse_to_one_relationship(link_value, relationship)
             elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-              if link_value.is_a?(Array) && link_value.length == 0
-                linkage = []
-              elsif link_value.is_a?(Hash)
-                linkage = link_value[:data]
-              else
-                fail JSONAPI::Exceptions::InvalidLinksObject.new
-              end
-
-              links_object = parse_to_many_links_object(linkage)
-
-              # Since we do not yet support polymorphic relationships we will raise an error if the type does not match the
-              # relationship's type.
-              # ToDo: Support Polymorphic relationships
-
-              if links_object.length == 0
-                checked_to_many_relationships[param] = []
-              else
-                if links_object.length > 1 || !links_object.has_key?(unformat_key(relationship.type).to_s)
-                  fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
-                end
-
-                links_object.each_pair do |type, keys|
-                  relationship_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
-                  checked_to_many_relationships[param] = relationship_resource.verify_keys(keys, @context)
-                end
+              parse_to_many_relationship(link_value, relationship) do |result_val|
+                checked_to_many_relationships[param] = result_val
               end
             end
           end
@@ -475,6 +432,61 @@ module JSONAPI
       }.deep_transform_keys { |key| unformat_key(key) }
     end
 
+    def parse_to_one_relationship(link_value, relationship)
+      if link_value.nil?
+        linkage = nil
+      else
+        linkage = link_value[:data]
+      end
+
+      links_object = parse_to_one_links_object(linkage)
+      if !relationship.polymorphic? && links_object[:type] && (links_object[:type].to_s != relationship.type.to_s)
+        fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+      end
+
+      unless links_object[:id].nil?
+        resource = self.resource_klass || Resource
+        relationship_resource = resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
+        relationship_id = relationship_resource.verify_key(links_object[:id], @context)
+        if relationship.polymorphic?
+          { id: relationship_id, type: unformat_key(links_object[:type].to_s) }
+        else
+          relationship_id
+        end
+      else
+        nil
+      end
+    end
+
+    def parse_to_many_relationship(link_value, relationship, &add_result)
+      if link_value.is_a?(Array) && link_value.length == 0
+        linkage = []
+      elsif link_value.is_a?(Hash)
+        linkage = link_value[:data]
+      else
+        fail JSONAPI::Exceptions::InvalidLinksObject.new
+      end
+
+      links_object = parse_to_many_links_object(linkage)
+
+      # Since we do not yet support polymorphic to_many relationships we will raise an error if the type does not match the
+      # relationship's type.
+      # ToDo: Support Polymorphic relationships
+
+      if links_object.length == 0
+        add_result.call([])
+      else
+        if links_object.length > 1 || !links_object.has_key?(unformat_key(relationship.type).to_s)
+          fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+        end
+
+        links_object.each_pair do |type, keys|
+          relationship_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
+          add_result.call relationship_resource.verify_keys(keys, @context)
+        end
+      end
+    end
+
     def unformat_value(attribute, value)
       value_formatter = JSONAPI::ValueFormatter.value_formatter_for(@resource_klass._attribute_options(attribute)[:format])
       value_formatter.unformat(value)

data/lib/jsonapi/resource.rb

@@ -165,10 +165,11 @@ module JSONAPI
       relationship_key_values.each do |relationship_key_value|
         related_resource = relationship.resource_klass.find_by_key(relationship_key_value, context: @context)
 
+        relation_name = relationship.relation_name(context: @context)
         # TODO: Add option to skip relations that already exist instead of returning an error?
-        relation = @model.public_send(relationship.type).where(relationship.primary_key => relationship_key_value).first
+        relation = @model.public_send(relation_name).where(relationship.primary_key => relationship_key_value).first
         if relation.nil?
-          @model.public_send(relationship.type) << related_resource.model
+          @model.public_send(relation_name) << related_resource.model
         else
           fail JSONAPI::Exceptions::HasManyRelationExists.new(relationship_key_value)
         end
@@ -544,9 +545,50 @@ module JSONAPI
         end
       end
 
-      # override to allow for key processing and checking
-      def verify_key(key, _context = nil)
-        key && Integer(key)
+      def key_type(key_type)
+        @_resource_key_type = key_type
+      end
+
+      def resource_key_type
+        @_resource_key_type || JSONAPI.configuration.resource_key_type
+      end
+
+      def verify_key(key, context = nil)
+        key_type = resource_key_type
+        verification_proc = case key_type
+
+        when :integer
+          -> (key, context) {
+            begin
+              return key if key.nil?
+              Integer(key)
+            rescue
+              raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+            end
+          }
+        when :string
+          -> (key, context) {
+            return key if key.nil?
+            if key.to_s.include?(',')
+              raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+            else
+              key
+            end
+          }
+        when :uuid
+          -> (key, context) {
+            return key if key.nil?
+            if key.to_s.match(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
+              key
+            else
+              raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+            end
+          }
+        else
+          key_type
+        end
+
+        verification_proc.call(key, context)
       rescue
         raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
       end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.5.7'
+    VERSION = '0.5.8'
   end
 end

data/lib/jsonapi/routing_ext.rb

@@ -68,6 +68,10 @@ module ActionDispatch
 
           options[:path] = format_route(@resource_type)
 
+          if res.resource_key_type == :uuid
+            options[:constraints] = {id: /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}(,[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})*/}
+          end
+
           if options[:except]
             options[:except] = Array(options[:except])
             options[:except] << :new unless options[:except].include?(:new) || options[:except].include?('new')

data/test/fixtures/active_record.rb

@@ -397,8 +397,11 @@ end
 class PurchaseOrder < ActiveRecord::Base
   belongs_to :customer
   has_many :line_items
+  has_many :admin_line_items, class_name: 'LineItem', foreign_key: 'purchase_order_id'
 
   has_and_belongs_to_many :order_flags, join_table: :purchase_orders_order_flags
+
+  has_and_belongs_to_many :admin_order_flags, join_table: :purchase_orders_order_flags, class_name: 'OrderFlag'
 end
 
 class OrderFlag < ActiveRecord::Base
@@ -618,6 +621,9 @@ module Api
     end
 
     class PurchaseOrdersController < JSONAPI::ResourceController
+      def context
+        {current_user: $test_user}
+      end
     end
 
     class LineItemsController < JSONAPI::ResourceController
@@ -794,16 +800,8 @@ class PostResource < JSONAPI::Resource
     return filter, values
   end
 
-  def self.is_num?(str)
-    begin
-      !!Integer(str)
-    rescue ArgumentError, TypeError
-      false
-    end
-  end
-
   def self.verify_key(key, context = nil)
-    raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key) unless is_num?(key)
+    super(key)
     raise JSONAPI::Exceptions::RecordNotFound.new(key) unless find_by_key(key, context: context)
     return key
   end
@@ -819,9 +817,7 @@ class IsoCurrencyResource < JSONAPI::Resource
 
   filter :country_name
 
-  def self.verify_key(key, context = nil)
-    key && String(key)
-  end
+  key_type :string
 end
 
 class ExpenseEntryResource < JSONAPI::Resource
@@ -1202,8 +1198,28 @@ module Api
       attribute :total
 
       has_one :customer
-      has_many :line_items
-      has_many :order_flags, acts_as_set: true
+      has_many :line_items, relation_name: -> (options = {}) {
+                            context = options[:context]
+                            current_user = context ? context[:current_user] : nil
+
+                            unless current_user && current_user.book_admin
+                              :line_items
+                            else
+                              :admin_line_items
+                            end
+                          }
+
+      has_many :order_flags, acts_as_set: true,
+               relation_name: -> (options = {}) {
+                             context = options[:context]
+                             current_user = context ? context[:current_user] : nil
+
+                             unless current_user && current_user.book_admin
+                               :order_flags
+                             else
+                               :admin_order_flags
+                             end
+                           }
     end
 
     class OrderFlagResource < JSONAPI::Resource

data/test/fixtures/customers.yml

@@ -5,3 +5,7 @@ xyz_corp:
 abc_corp:
   id: 2
   name: ABC Corporation
+
+asdfg_corp:
+  id: 3
+  name: ASDFG Corporation

data/test/fixtures/line_items.yml

@@ -28,4 +28,10 @@ li_5:
   id: 5
   part_number: 5WERT
   quantity: 1
-  item_cost: 299.98
+  item_cost: 299.98
+
+li_6:
+  id: 6
+  part_number: 25washer
+  quantity: 10
+  item_cost: 0.98

data/test/fixtures/purchase_orders.yml

@@ -15,3 +15,9 @@ po_3:
   requested_delivery_date:
   delivery_date: nil
   customer_id: 1
+
+po_4:
+  id: 4
+  requested_delivery_date:
+  delivery_date: nil
+  customer_id: 3

data/test/integration/requests/request_test.rb

@@ -426,6 +426,16 @@ class RequestTest < ActionDispatch::IntegrationTest
     JSONAPI.configuration.top_level_meta_include_record_count = false
   end
 
+  def test_filter_related_resources
+    JSONAPI.configuration.top_level_meta_include_record_count = true
+    get '/api/v2/books/1/book_comments?filter[book]=2'
+    assert_equal 0, json_response['meta']['record_count']
+    get '/api/v2/books/1/book_comments?filter[book]=1&page[limit]=20'
+    assert_equal 26, json_response['meta']['record_count']
+  ensure
+    JSONAPI.configuration.top_level_meta_include_record_count = false
+  end
+
   def test_pagination_related_resources_without_related
     Api::V2::BookResource.paginator :offset
     Api::V2::BookCommentResource.paginator :offset
@@ -750,6 +760,40 @@ class RequestTest < ActionDispatch::IntegrationTest
     JSONAPI.configuration = original_config
   end
 
+  def test_patch_formatted_dasherized_replace_to_many_computed_relation
+    $original_test_user = $test_user
+    $test_user = Person.find(5)
+    original_config = JSONAPI.configuration.dup
+    JSONAPI.configuration.route_format = :dasherized_route
+    JSONAPI.configuration.json_key_format = :dasherized_key
+    patch '/api/v6/purchase-orders/2?include=line-items,order-flags',
+          {
+            'data' => {
+              'id' => '2',
+              'type' => 'purchase-orders',
+              'relationships' => {
+                'line-items' => {
+                  'data' => [
+                    {'type' => 'line-items', 'id' => '3'},
+                    {'type' => 'line-items', 'id' => '4'}
+                  ]
+                },
+                'order-flags' => {
+                  'data' => [
+                    {'type' => 'order-flags', 'id' => '1'},
+                    {'type' => 'order-flags', 'id' => '2'}
+                  ]
+                }
+              }
+            }
+          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
+
+    assert_equal 200, status
+  ensure
+    JSONAPI.configuration = original_config
+    $test_user = $original_test_user
+  end
+
   def test_post_to_many_link
     original_config = JSONAPI.configuration.dup
     JSONAPI.configuration.route_format = :dasherized_route
@@ -767,6 +811,26 @@ class RequestTest < ActionDispatch::IntegrationTest
     JSONAPI.configuration = original_config
   end
 
+  def test_post_computed_relation_to_many
+    $original_test_user = $test_user
+    $test_user = Person.find(5)
+    original_config = JSONAPI.configuration.dup
+    JSONAPI.configuration.route_format = :dasherized_route
+    JSONAPI.configuration.json_key_format = :dasherized_key
+    post '/api/v6/purchase-orders/4/relationships/line-items',
+         {
+           'data' => [
+             {'type' => 'line-items', 'id' => '5'},
+             {'type' => 'line-items', 'id' => '6'}
+           ]
+         }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
+
+    assert_equal 204, status
+  ensure
+    JSONAPI.configuration = original_config
+    $test_user = $original_test_user
+  end
+
   def test_patch_to_many_link
     original_config = JSONAPI.configuration.dup
     JSONAPI.configuration.route_format = :dasherized_route
@@ -784,6 +848,26 @@ class RequestTest < ActionDispatch::IntegrationTest
     JSONAPI.configuration = original_config
   end
 
+  def test_patch_to_many_link_computed_relation
+    $original_test_user = $test_user
+    $test_user = Person.find(5)
+    original_config = JSONAPI.configuration.dup
+    JSONAPI.configuration.route_format = :dasherized_route
+    JSONAPI.configuration.json_key_format = :dasherized_key
+    patch '/api/v6/purchase-orders/4/relationships/order-flags',
+          {
+            'data' => [
+              {'type' => 'order-flags', 'id' => '1'},
+              {'type' => 'order-flags', 'id' => '2'}
+            ]
+          }.to_json, "CONTENT_TYPE" => JSONAPI::MEDIA_TYPE
+
+    assert_equal 204, status
+  ensure
+    JSONAPI.configuration = original_config
+    $test_user = $original_test_user
+  end
+
   def test_patch_to_one
     original_config = JSONAPI.configuration.dup
     JSONAPI.configuration.route_format = :dasherized_route

data/test/integration/routes/routes_test.rb

@@ -52,6 +52,17 @@ class RoutesTest < ActionDispatch::IntegrationTest
                    {controller: 'posts', action: 'update_relationship', post_id: '1', relationship: 'tags'})
   end
 
+  def test_routing_uuid
+    assert_routing({path: '/pets/v1/cats/f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5', method: :get},
+                   {action: 'show', controller: 'pets/v1/cats', id: 'f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5'})
+  end
+
+  # ToDo: refute this routing
+  # def test_routing_uuid_bad_format
+  #   assert_routing({path: '/pets/v1/cats/f1a4d5f2-e77a-4d0a-acbb-ee0b9', method: :get},
+  #                  {action: 'show', controller: 'pets/v1/cats', id: 'f1a4d5f2-e77a-4d0a-acbb-ee0b98'})
+  # end
+
   # Polymorphic
   def test_routing_polymorphic_get_related_resource
     assert_routing(

data/test/lib/generators/jsonapi/resource_generator_test.rb

@@ -17,6 +17,11 @@ module Jsonapi
       assert_file 'app/resources/post_resource.rb', /class PostResource < JSONAPI::Resource/
     end
 
+    test "resource is singular" do
+      run_generator ["posts"]
+      assert_file 'app/resources/post_resource.rb', /class PostResource < JSONAPI::Resource/
+    end
+
     test "resource is created with namespace" do
       run_generator ["api/v1/post"]
       assert_file 'app/resources/api/v1/post_resource.rb', /class Api::V1::PostResource < JSONAPI::Resource/

data/test/test_helper.rb

@@ -95,6 +95,22 @@ TestApp.initialize!
 
 require File.expand_path('../fixtures/active_record', __FILE__)
 
+module Pets
+  module V1
+    class CatsController < JSONAPI::ResourceController
+
+    end
+
+    class CatResource < JSONAPI::Resource
+      attribute :id
+      attribute :name
+      attribute :breed
+
+      key_type :uuid
+    end
+  end
+end
+
 JSONAPI.configuration.route_format = :underscored_route
 TestApp.routes.draw do
   jsonapi_resources :people
@@ -214,6 +230,12 @@ TestApp.routes.draw do
     end
   end
 
+  namespace :pets do
+    namespace :v1 do
+      jsonapi_resources :cats
+    end
+  end
+
   mount MyEngine::Engine => "/boomshaka", as: :my_engine
 end
 

data/test/unit/resource/resource_test.rb

@@ -195,6 +195,7 @@ class ResourceTest < ActiveSupport::TestCase
     filtered_comments = post_resource.comments({ filters: { body: 'i liked it' } })
     assert_equal(1, filtered_comments.size)
 
+  ensure
     # reset method to original implementation
     PostResource.instance_eval do
       def apply_filters(records, filters, options)
@@ -222,6 +223,7 @@ class ResourceTest < ActiveSupport::TestCase
     sorted_comment_ids = post_resource.comments(sort_criteria: [{ field: 'id', direction: 'desc'}]).map{|c| c.model.id }
     assert_equal [2,1], sorted_comment_ids
 
+  ensure
     # reset method to original implementation
     PostResource.instance_eval do
       def apply_sort(records, criteria)
@@ -260,6 +262,7 @@ class ResourceTest < ActiveSupport::TestCase
     paged_comments = post_resource.comments(paginator: paginator_class.new(1))
     assert_equal 1, paged_comments.size
 
+  ensure
     # reset method to original implementation
     PostResource.instance_eval do
       def apply_pagination(records, criteria, order_options)
@@ -269,4 +272,81 @@ class ResourceTest < ActiveSupport::TestCase
       end
     end
   end
+
+  def test_key_type_integer
+    CatResource.instance_eval do
+      key_type :integer
+    end
+
+    assert CatResource.verify_key('45')
+    assert CatResource.verify_key(45)
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('45,345')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
+
+  def test_key_type_string
+    CatResource.instance_eval do
+      key_type :string
+    end
+
+    assert CatResource.verify_key('45')
+    assert CatResource.verify_key(45)
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('45,345')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
+
+  def test_key_type_uuid
+    CatResource.instance_eval do
+      key_type :uuid
+    end
+
+    assert CatResource.verify_key('f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5')
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('f1a-e77a-4d0a-acbb-ee0b98b3f6b5')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
+
+  def test_key_type_proc
+    CatResource.instance_eval do
+      key_type -> (key, context) {
+        return key if key.nil?
+        if key.to_s.match(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
+          key
+        else
+          raise JSONAPI::Exceptions::InvalidFieldValue.new(:id, key)
+        end
+      }
+    end
+
+    assert CatResource.verify_key('f1a4d5f2-e77a-4d0a-acbb-ee0b98b3f6b5')
+
+    assert_raises JSONAPI::Exceptions::InvalidFieldValue do
+      CatResource.verify_key('f1a-e77a-4d0a-acbb-ee0b98b3f6b5')
+    end
+
+  ensure
+    CatResource.instance_eval do
+      key_type nil
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.5.8
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-13 00:00:00.000000000 Z
+date: 2015-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler