jsonapi-resources 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dde1ba06781fcada973e949ba64e7b7821c8b23
-  data.tar.gz: cf3aefe531485a4ed3efeba48cf9b7deecf78a74
+  metadata.gz: 2d31c91126186e543683030f0b2c2a0fb513d64e
+  data.tar.gz: 8bd319a9b582d306093f9cfaf82733f5edeb7aa1
 SHA512:
-  metadata.gz: 89cb1ccd8c7b620cced0007df3735ddec354e972e2a7f1a88907277089a5e509a23c7e90bb877bf676fd5edd6e71a49028b698fb888656a37854361e40a25c83
-  data.tar.gz: 2a7211219f7ae1849220122d49fc785b41639a48b79d3666fa8da553957ed6f09031e61c2aad6311117b558f8fc73232f9094ebd8c2bc914ff6c73e1779a0202
+  metadata.gz: d4b2634d12eba8207a651bdb60a42e82bb85136d7098feaaf70821ea58c8200636b8b4e480a423b8ab8e1af1f2f8837cb33fe307adf55843c6da770e4c02e7f9
+  data.tar.gz: ebd5e529dd9662930ee305309cba83324325e090abdda8fcb7cf6a8cc204b437fde534d6de58d5815c5c1278efa9c527b4ea6ce3113940fcc651b00c5015bd37

data/README.md

@@ -260,7 +260,7 @@ end
 
 ##### Finders
 
-Basic finding by filters is supported by resources. However if you have more complex requirements for finding you can override the `find` and `find_by_key` methods on the resource.
+Basic finding by filters is supported by resources. However 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.
 
 Here's an example that defers the `find` operation to a `current_user` set on the `context` option:
 
@@ -283,6 +283,23 @@ class AuthorResource < JSONAPI::Resource
 end
 ```
 
+##### 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.
+
+For example to allow a user to only retrieve his own posts you can do the following:
+
+```ruby
+class PostResource < JSONAPI::Resource
+  attribute :id, :title, :body
+
+  def self.records(options = {})
+    context = options[:context]
+    context.current_user.posts
+  end
+end
+```
+
 ### Controllers
 
 JSONAPI::Resources provides a class, `ResourceController`, that can be used as the base class for your controllers. `ResourceController` supports `index`, `show`, `create`, `update`, and `destroy` methods. Just deriving your controller from `ResourceController` will give you a fully functional controller.
@@ -345,12 +362,14 @@ These codes can be customized in your app by creating an initializer to override
 
 ### Serializer
 
-The `ResourceSerializer` can be used to serialize a resource into JSON API compliant JSON. `ResourceSerializer` has a `serialize_to_hash` method that takes a resource instance to serialize. For example:
+The `ResourceSerializer` can be used to serialize a resource into JSON API compliant JSON. `ResourceSerializer` must be
+ initialized with the primary resource type it will be serializing. `ResourceSerializer` has a `serialize_to_hash`
+ method that takes a resource instance or array of resource instances to serialize. For example:
 
 ```ruby
 require 'jsonapi/resource_serializer'
 post = Post.find(1)
-JSONAPI::ResourceSerializer.new.serialize_to_hash(PostResource.new(post))
+JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(PostResource.new(post))
 ```
 
 This returns results like this:
@@ -393,7 +412,7 @@ A hash of resource types and arrays of fields for each resource type.
 
 ```ruby
 post = Post.find(1)
-JSONAPI::ResourceSerializer.new.serialize_to_hash(PostResource.new(post),
+JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(PostResource.new(post),
         include: ['comments','author','comments.tags','author.posts'],
         fields: {
                  people: [:id, :email, :comments],

data/lib/jsonapi/configuration.rb

@@ -2,17 +2,31 @@ require 'jsonapi/formatter'
 
 module JSONAPI
   class Configuration
-    attr_reader :json_key_format, :key_formatter
+    attr_reader :json_key_format, :key_formatter, :allowed_request_params, :route_format, :route_formatter
 
     def initialize
       #:underscored_key, :camelized_key, :dasherized_key, or custom
       self.json_key_format = :underscored_key
+
+      #:underscored_route, :camelized_route, :dasherized_route, or custom
+      self.route_format = :underscored_route
+
+      self.allowed_request_params = [:include, :fields, :format, :controller, :action, :sort]
     end
 
     def json_key_format=(format)
       @json_key_format = format
       @key_formatter = JSONAPI::Formatter.formatter_for(format)
     end
+
+    def route_format=(format)
+      @route_format = format
+      @route_formatter = JSONAPI::Formatter.formatter_for(format)
+    end
+
+    def allowed_request_params=(allowed_request_params)
+      @allowed_request_params = allowed_request_params
+    end
   end
 
   class << self

data/lib/jsonapi/formatter.rb

@@ -37,6 +37,18 @@ module JSONAPI
     end
   end
 
+  class RouteFormatter < Formatter
+    class << self
+      def format(route)
+        super
+      end
+
+      def unformat(formatted_route)
+        super.to_sym
+      end
+    end
+  end
+
   class ValueFormatter < Formatter
     class << self
       def format(raw_value, context)
@@ -93,4 +105,31 @@ class DefaultValueFormatter < JSONAPI::ValueFormatter
       end
     end
   end
+end
+
+class UnderscoredRouteFormatter < JSONAPI::RouteFormatter
+end
+
+class CamelizedRouteFormatter < JSONAPI::RouteFormatter
+  class << self
+    def format(route)
+      super.camelize(:lower)
+    end
+
+    def unformat(formatted_route)
+      formatted_route.to_s.underscore.to_sym
+    end
+  end
+end
+
+class DasherizedRouteFormatter < JSONAPI::RouteFormatter
+  class << self
+    def format(route)
+      super.dasherize
+    end
+
+    def unformat(formatted_route)
+      formatted_route.to_s.underscore.to_sym
+    end
+  end
 end

data/lib/jsonapi/request.rb

@@ -134,9 +134,11 @@ module JSONAPI
       params.each do |key, value|
         filter = key.to_sym
 
-        if [:include, :fields, :format, :controller, :action, :sort].include?(filter)
-          # Ignore non-filter parameters
-        elsif @resource_klass._allowed_filter?(filter)
+        # Ignore non-filter parameters
+        next if JSONAPI.configuration.allowed_request_params.include?(filter)
+
+        filter = unformat_key(key).to_sym
+        if @resource_klass._allowed_filter?(filter)
           filters[filter] = value
         else
           @errors.concat(JSONAPI::Exceptions::FilterNotAllowed.new(filter).errors)
@@ -147,8 +149,18 @@ module JSONAPI
 
     def parse_sort_params(params)
       @sort_params = if params[:sort].present?
-        CSV.parse_line(params[:sort]).each do |sort_param|
-          check_sort_param(@resource_klass, sort_param)
+        CSV.parse_line(params[:sort]).collect do |sort_param|
+          # A parameter name may not start with a dash
+          # We need to preserve the dash as the sort direction before we unformat the string
+          if sort_param.start_with?('-')
+            unformatted_sort_param = unformat_key(sort_param[1..-1]).to_s
+            unformatted_sort_param.prepend('-')
+          else
+            unformatted_sort_param = unformat_key(sort_param).to_s
+          end
+
+          check_sort_param(@resource_klass, unformatted_sort_param)
+          unformatted_sort_param
         end
       else
         []

data/lib/jsonapi/resource.rb

@@ -239,7 +239,7 @@ module JSONAPI
 
         resources = []
         order_options = construct_order_options(sort_params)
-        _model_class.where(where_filters).order(order_options).includes(includes).each do |model|
+        records(options).where(where_filters).order(order_options).includes(includes).each do |model|
           resources.push self.new(model, context)
         end
 
@@ -248,7 +248,7 @@ module JSONAPI
 
       def find_by_key(key, options = {})
         context = options[:context]
-        model = _model_class.where({_primary_key => key}).first
+        model = records(options).where({_primary_key => key}).first
         if model.nil?
           raise JSONAPI::Exceptions::RecordNotFound.new(key)
         end
@@ -257,7 +257,7 @@ module JSONAPI
 
       def find_by_keys(keys, options = {})
         context = options[:context]
-        _models = _model_class.where({_primary_key => keys})
+        _models = records(options).where({_primary_key => keys})
 
         unless _models.length == keys.length
           key = (keys - _models.pluck(:id).map(&:to_s)).first
@@ -267,6 +267,12 @@ module JSONAPI
         _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)
+      def records(options = {})
+        _model_class
+      end
+
       def verify_filters(filters, context = nil)
         verified_filters = {}
         filters.each do |filter, raw_value|

data/lib/jsonapi/resource_controller.rb

@@ -16,7 +16,7 @@ module JSONAPI
     before_filter :setup_request
 
     def index
-      render json: JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      render json: JSONAPI::ResourceSerializer.new(resource_klass).serialize_to_hash(
           resource_klass.find(resource_klass.verify_filters(@request.filters, context),
             context: context, sort_params: @request.sort_params),
           include: @request.include,
@@ -36,7 +36,7 @@ module JSONAPI
                     resource_klass.find_by_key(keys[0], context: context)
                   end
 
-      render json: JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      render json: JSONAPI::ResourceSerializer.new(resource_klass).serialize_to_hash(
           resources,
           include: @request.include,
           fields: @request.fields,
@@ -54,7 +54,7 @@ module JSONAPI
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
       association = resource_klass._association(association_type)
-      render json: { association_type => parent_resource.send(association.foreign_key)}
+      render json: { key_formatter.format(association_type) => parent_resource.send(association.foreign_key)}
     rescue => e
       # :nocov:
       handle_exceptions(e)
@@ -168,11 +168,12 @@ module JSONAPI
       else
         if results.length > 0 && resources.length > 0
           render status: results[0].code,
-                 json: JSONAPI::ResourceSerializer.new.serialize_to_hash(resources.length > 1 ? resources : resources[0],
-                                                                         include: @request.include,
-                                                                         fields: @request.fields,
-                                                                         attribute_formatters: attribute_formatters,
-                                                                         key_formatter: key_formatter)
+                 json: JSONAPI::ResourceSerializer.new(resource_klass).serialize_to_hash(
+                   resources.length > 1 ? resources : resources[0],
+                   include: @request.include,
+                   fields: @request.fields,
+                   attribute_formatters: attribute_formatters,
+                   key_formatter: key_formatter)
         else
           render status: results[0].code, json: nil
         end

data/lib/jsonapi/resource_serializer.rb

@@ -1,6 +1,11 @@
 module JSONAPI
   class ResourceSerializer
 
+    def initialize(primary_resource_klass)
+      @primary_resource_klass = primary_resource_klass
+      @primary_class_name = @primary_resource_klass._type
+    end
+
     # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
     # include:
     #     Purpose: determines which objects will be side loaded with the source objects in a linked section
@@ -11,7 +16,6 @@ module JSONAPI
     #     Example: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
     def serialize_to_hash(source, options = {})
       is_resource_collection = source.respond_to?(:to_ary)
-      return {} if source.nil? || (is_resource_collection && source.size == 0)
 
       @fields =  options.fetch(:fields, {})
       include = options.fetch(:include, [])
@@ -22,16 +26,8 @@ module JSONAPI
 
       requested_associations = parse_includes(include)
 
-      if is_resource_collection
-        @primary_class_name = source[0].class._type
-      else
-        @primary_class_name = source.class._type
-      end
-
       process_primary(source, requested_associations)
 
-      primary_class_name = @primary_class_name.to_sym
-
       linked_hash = {}
       primary_objects = []
       @linked_objects.each do |class_name, objects|
@@ -49,9 +45,9 @@ module JSONAPI
       end
 
       if is_resource_collection
-        primary_hash = {format_key(primary_class_name) => primary_objects}
+        primary_hash = {format_key(@primary_class_name) => primary_objects}
       else
-        primary_hash = {format_key(primary_class_name) => primary_objects[0]}
+        primary_hash = {format_key(@primary_class_name) => primary_objects[0]}
       end
 
       if linked_hash.size > 0

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = "0.0.12"
+    VERSION = "0.0.13"
   end
 end

data/lib/jsonapi/routing_ext.rb

@@ -1,14 +1,32 @@
 module ActionDispatch
   module Routing
     class Mapper
+
+      Resource.class_eval do
+        def unformat_route(route)
+          JSONAPI.configuration.route_formatter.unformat(route.to_s)
+        end
+
+        def nested_param
+          :"#{unformat_route(singular)}_#{param}"
+        end
+      end
+
       Resources.class_eval do
+        def format_route(route)
+          JSONAPI.configuration.route_formatter.format(route.to_s)
+        end
+
         def jsonapi_resource(*resources, &block)
           resource_type = resources.first
-          options = resources.extract_options!.dup
-
           res = JSONAPI::Resource.resource_for(resource_type)
 
-          resource resource_type, options.merge(res.routing_resource_options) do
+          options = resources.extract_options!.dup
+          options[:controller] ||= resource_type
+          options.merge!(res.routing_resource_options)
+          options[:path] = format_route(resource_type)
+
+          resource resource_type, options do
             @scope[:jsonapi_resource] = resource_type
 
             if block_given?
@@ -27,14 +45,18 @@ module ActionDispatch
 
         def jsonapi_resources(*resources, &block)
           resource_type = resources.first
-          options = resources.extract_options!.dup
-
           res = JSONAPI::Resource.resource_for(resource_type)
 
+          options = resources.extract_options!.dup
+          options[:controller] ||= resource_type
+          options.merge!(res.routing_resource_options)
+
           # Route using the primary_key. Can be overridden using routing_resource_options
-          options.merge!(param: res._primary_key)
+          options[:param] ||= res._primary_key
+
+          options[:path] = format_route(resource_type)
 
-          resources resource_type, options.merge(res.routing_resource_options) do
+          resources resource_type, options do
             @scope[:jsonapi_resource] = resource_type
 
             if block_given?
@@ -64,6 +86,7 @@ module ActionDispatch
 
         def jsonapi_link(*links)
           link_type = links.first
+          formatted_association_name = format_route(link_type)
           options = links.extract_options!.dup
 
           res = JSONAPI::Resource.resource_for(@scope[:jsonapi_resource])
@@ -71,24 +94,29 @@ module ActionDispatch
           methods = links_methods(options)
 
           if methods.include?(:show)
-            match "links/#{link_type}", controller: res._type.to_s, action: 'show_association', association: link_type.to_s, via: [:get]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'show_association', association: link_type.to_s, via: [:get]
           end
 
           if methods.include?(:create)
-            match "links/#{link_type}", controller: res._type.to_s, action: 'create_association', association: link_type.to_s, via: [:post]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'create_association', association: link_type.to_s, via: [:post]
           end
 
           if methods.include?(:update)
-            match "links/#{link_type}", controller: res._type.to_s, action: 'update_association', association: link_type.to_s, via: [:put]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'update_association', association: link_type.to_s, via: [:put]
           end
 
           if methods.include?(:destroy)
-            match "links/#{link_type}", controller: res._type.to_s, action: 'destroy_association', association: link_type.to_s, via: [:delete]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'destroy_association', association: link_type.to_s, via: [:delete]
           end
         end
 
         def jsonapi_links(*links)
           link_type = links.first
+          formatted_association_name = format_route(link_type)
           options = links.extract_options!.dup
 
           res = JSONAPI::Resource.resource_for(@scope[:jsonapi_resource])
@@ -96,19 +124,23 @@ module ActionDispatch
           methods = links_methods(options)
 
           if methods.include?(:show)
-            match "links/#{link_type}", controller: res._type.to_s, action: 'show_association', association: link_type.to_s, via: [:get]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'show_association', association: link_type.to_s, via: [:get]
           end
 
           if methods.include?(:create)
-            match "links/#{link_type}", controller: res._type.to_s, action: 'create_association', association: link_type.to_s, via: [:post]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'create_association', association: link_type.to_s, via: [:post]
           end
 
           if methods.include?(:update) && res._association(link_type).acts_as_set
-            match "links/#{link_type}", controller: res._type.to_s, action: 'update_association', association: link_type.to_s, via: [:put]
+            match "links/#{formatted_association_name}", controller: res._type.to_s,
+                  action: 'update_association', association: link_type.to_s, via: [:put]
           end
 
           if methods.include?(:destroy)
-            match "links/#{link_type}/:keys", controller: res._type.to_s, action: 'destroy_association', association: link_type.to_s, via: [:delete]
+            match "links/#{formatted_association_name}/:keys", controller: res._type.to_s,
+                  action: 'destroy_association', association: link_type.to_s, via: [:delete]
           end
         end
       end

data/test/controllers/controller_test.rb

@@ -8,6 +8,13 @@ class PostsControllerTest < ActionController::TestCase
     assert json_response['posts'].is_a?(Array)
   end
 
+  def test_index_filter_with_empty_result
+    get :index, {title: 'post that does not exist'}
+    assert_response :success
+    assert json_response['posts'].is_a?(Array)
+    assert_equal 0, json_response['posts'].size
+  end
+
   def test_index_filter_by_id
     get :index, {id: '1'}
     assert_response :success
@@ -100,7 +107,7 @@ class PostsControllerTest < ActionController::TestCase
   def test_filter_associations_multiple_not_found
     get :index, {tags: '1', comments: '3'}
     assert_response :success
-    assert_equal 0, json_response.size
+    assert_equal 0, json_response['posts'].size
   end
 
   def test_bad_filter
@@ -1166,30 +1173,31 @@ class IsoCurrenciesControllerTest < ActionController::TestCase
   end
 
   def test_currencies_index
+    JSONAPI.configuration.json_key_format = :camelized_key
     get :index
     assert_response :success
-    assert_equal 2, json_response['isoCurrencies'].size
+    assert_equal 3, json_response['isoCurrencies'].size
   end
 
   def test_currencies_json_key_underscored
     JSONAPI.configuration.json_key_format = :underscored_key
     get :index
     assert_response :success
-    assert_equal 2, json_response['iso_currencies'].size
+    assert_equal 3, json_response['iso_currencies'].size
   end
 
   def test_currencies_json_key_dasherized
     JSONAPI.configuration.json_key_format = :dasherized_key
     get :index
     assert_response :success
-    assert_equal 2, json_response['iso-currencies'].size
+    assert_equal 3, json_response['iso-currencies'].size
   end
 
   def test_currencies_custom_json_key
     JSONAPI.configuration.json_key_format = :upper_camelized_key
     get :index
     assert_response :success
-    assert_equal 2, json_response['IsoCurrencies'].size
+    assert_equal 3, json_response['IsoCurrencies'].size
   end
 
   def test_currencies_show
@@ -1197,6 +1205,84 @@ class IsoCurrenciesControllerTest < ActionController::TestCase
     assert_response :success
     assert json_response['isoCurrencies'].is_a?(Hash)
   end
+
+  def test_currencies_json_key_underscored_sort
+    JSONAPI.configuration.json_key_format = :underscored_key
+    get :index, {sort: 'country_name'}
+    assert_response :success
+    assert_equal 3, json_response['iso_currencies'].size
+    assert_equal 'Canada', json_response['iso_currencies'][0]['country_name']
+    assert_equal 'Euro Member Countries', json_response['iso_currencies'][1]['country_name']
+    assert_equal 'United States', json_response['iso_currencies'][2]['country_name']
+
+    # reverse sort
+    get :index, {sort: '-country_name'}
+    assert_response :success
+    assert_equal 3, json_response['iso_currencies'].size
+    assert_equal 'United States', json_response['iso_currencies'][0]['country_name']
+    assert_equal 'Euro Member Countries', json_response['iso_currencies'][1]['country_name']
+    assert_equal 'Canada', json_response['iso_currencies'][2]['country_name']
+  end
+
+  def test_currencies_json_key_dasherized_sort
+    JSONAPI.configuration.json_key_format = :dasherized_key
+    get :index, {sort: 'country-name'}
+    assert_response :success
+    assert_equal 3, json_response['iso-currencies'].size
+    assert_equal 'Canada', json_response['iso-currencies'][0]['country-name']
+    assert_equal 'Euro Member Countries', json_response['iso-currencies'][1]['country-name']
+    assert_equal 'United States', json_response['iso-currencies'][2]['country-name']
+
+    # reverse sort
+    get :index, {sort: '-country-name'}
+    assert_response :success
+    assert_equal 3, json_response['iso-currencies'].size
+    assert_equal 'United States', json_response['iso-currencies'][0]['country-name']
+    assert_equal 'Euro Member Countries', json_response['iso-currencies'][1]['country-name']
+    assert_equal 'Canada', json_response['iso-currencies'][2]['country-name']
+  end
+
+  def test_currencies_json_key_custom_json_key_sort
+    JSONAPI.configuration.json_key_format = :upper_camelized_key
+    get :index, {sort: 'CountryName'}
+    assert_response :success
+    assert_equal 3, json_response['IsoCurrencies'].size
+    assert_equal 'Canada', json_response['IsoCurrencies'][0]['CountryName']
+    assert_equal 'Euro Member Countries', json_response['IsoCurrencies'][1]['CountryName']
+    assert_equal 'United States', json_response['IsoCurrencies'][2]['CountryName']
+
+    # reverse sort
+    get :index, {sort: '-CountryName'}
+    assert_response :success
+    assert_equal 3, json_response['IsoCurrencies'].size
+    assert_equal 'United States', json_response['IsoCurrencies'][0]['CountryName']
+    assert_equal 'Euro Member Countries', json_response['IsoCurrencies'][1]['CountryName']
+    assert_equal 'Canada', json_response['IsoCurrencies'][2]['CountryName']
+  end
+
+  def test_currencies_json_key_underscored_filter
+    JSONAPI.configuration.json_key_format = :underscored_key
+    get :index, {country_name: 'Canada'}
+    assert_response :success
+    assert_equal 1, json_response['iso_currencies'].size
+    assert_equal 'Canada', json_response['iso_currencies'][0]['country_name']
+  end
+
+  def test_currencies_json_key_camelized_key_filter
+    JSONAPI.configuration.json_key_format = :camelized_key
+    get :index, {'countryName' => 'Canada'}
+    assert_response :success
+    assert_equal 1, json_response['isoCurrencies'].size
+    assert_equal 'Canada', json_response['isoCurrencies'][0]['countryName']
+  end
+
+  def test_currencies_json_key_custom_json_key_filter
+    JSONAPI.configuration.json_key_format = :upper_camelized_key
+    get :index, {'CountryName' => 'Canada'}
+    assert_response :success
+    assert_equal 1, json_response['IsoCurrencies'].size
+    assert_equal 'Canada', json_response['IsoCurrencies'][0]['CountryName']
+  end
 end
 
 class PeopleControllerTest < ActionController::TestCase

data/test/fixtures/active_record.rb

@@ -288,6 +288,28 @@ module Api
     class PostsController < JSONAPI::ResourceController
     end
   end
+
+  module V4
+    class PostsController < JSONAPI::ResourceController
+    end
+
+    class ExpenseEntriesController < JSONAPI::ResourceController
+    end
+
+    class IsoCurrenciesController < JSONAPI::ResourceController
+    end
+  end
+
+  module V5
+    class PostsController < JSONAPI::ResourceController
+    end
+
+    class ExpenseEntriesController < JSONAPI::ResourceController
+    end
+
+    class IsoCurrenciesController < JSONAPI::ResourceController
+    end
+  end
 end
 
 ### RESOURCES
@@ -414,6 +436,8 @@ end
 class IsoCurrencyResource < JSONAPI::Resource
   primary_key :code
   attributes :id, :name, :country_name, :minor_unit
+
+  filter :country_name
 end
 
 class ExpenseEntryResource < JSONAPI::Resource
@@ -616,6 +640,7 @@ end
 
 IsoCurrency.create(code: 'USD', name: 'United States Dollar', country_name: 'United States', minor_unit: 'cent')
 IsoCurrency.create(code: 'EUR', name: 'Euro Member Countries', country_name: 'Euro Member Countries', minor_unit: 'cent')
+IsoCurrency.create(code: 'CAD', name: 'Canadian dollar', country_name: 'Canada', minor_unit: 'cent')
 
 ExpenseEntry.create(currency_code: 'USD',
                employee_id: c.id,

data/test/integration/requests/request_test.rb

@@ -8,6 +8,43 @@ class RequestTest < ActionDispatch::IntegrationTest
     assert_equal 200, status
   end
 
+  def test_get_underscored_key
+    JSONAPI.configuration.json_key_format = :underscored_key
+    get '/iso_currencies'
+    assert_equal 200, status
+    assert_equal 3, json_response['iso_currencies'].size
+  end
+
+  def test_get_underscored_key_filtered
+    JSONAPI.configuration.json_key_format = :underscored_key
+    get '/iso_currencies?country_name=Canada'
+    assert_equal 200, status
+    assert_equal 1, json_response['iso_currencies'].size
+    assert_equal 'Canada', json_response['iso_currencies'][0]['country_name']
+  end
+
+  def test_get_camelized_key_filtered
+    JSONAPI.configuration.json_key_format = :camelized_key
+    get '/iso_currencies?countryName=Canada'
+    assert_equal 200, status
+    assert_equal 1, json_response['isoCurrencies'].size
+    assert_equal 'Canada', json_response['isoCurrencies'][0]['countryName']
+  end
+
+  def test_get_camelized_route_and_key_filtered
+    get '/api/v4/isoCurrencies?countryName=Canada'
+    assert_equal 200, status
+    assert_equal 1, json_response['isoCurrencies'].size
+    assert_equal 'Canada', json_response['isoCurrencies'][0]['countryName']
+  end
+
+  def test_get_camelized_route_and_links
+    JSONAPI.configuration.json_key_format = :camelized_key
+    get '/api/v4/expenseEntries/1/links/isoCurrency'
+    assert_equal 200, status
+    assert_equal 'USD', json_response['isoCurrency']
+  end
+
   def test_put_single
     put '/posts/3',
         {

data/test/integration/routes/routes_test.rb

@@ -111,6 +111,44 @@ class RoutesTest < ActionDispatch::IntegrationTest
                    {action: 'show', controller: 'api/v3/posts', id: '1'})
   end
 
+  # V4 camelCase
+  def test_routing_v4_posts_show
+    assert_routing({path: '/api/v4/posts/1', method: :get},
+                   {action: 'show', controller: 'api/v4/posts', id: '1'})
+  end
+
+  def test_routing_v4_isoCurrencies_resources
+    assert_routing({path: '/api/v4/isoCurrencies/USD', method: :get},
+                   {action: 'show', controller: 'api/v4/iso_currencies', code: 'USD'})
+  end
+
+  def test_routing_v4_expenseEntries_resources
+    assert_routing({path: '/api/v4/expenseEntries/1', method: :get},
+                   {action: 'show', controller: 'api/v4/expense_entries', id: '1'})
+
+    assert_routing({path: '/api/v4/expenseEntries/1/links/isoCurrency', method: :get},
+                   {controller: 'api/v4/expense_entries', action: 'show_association', expense_entry_id: '1', association: 'iso_currency'})
+  end
+
+  # V5 dasherized
+  def test_routing_v5_posts_show
+    assert_routing({path: '/api/v5/posts/1', method: :get},
+                   {action: 'show', controller: 'api/v5/posts', id: '1'})
+  end
+
+  def test_routing_v5_isoCurrencies_resources
+    assert_routing({path: '/api/v5/iso-currencies/USD', method: :get},
+                   {action: 'show', controller: 'api/v5/iso_currencies', code: 'USD'})
+  end
+
+  def test_routing_v5_expenseEntries_resources
+    assert_routing({path: '/api/v5/expense-entries/1', method: :get},
+                   {action: 'show', controller: 'api/v5/expense_entries', id: '1'})
+
+    assert_routing({path: '/api/v5/expense-entries/1/links/iso-currency', method: :get},
+                   {controller: 'api/v5/expense_entries', action: 'show_association', expense_entry_id: '1', association: 'iso_currency'})
+  end
+  
   #primary_key
   def test_routing_primary_key_jsonapi_resources
     assert_routing({path: '/iso_currencies/USD', method: :get},
@@ -135,5 +173,4 @@ class RoutesTest < ActionDispatch::IntegrationTest
 
   # Test that non acts as set has_many association update route is not created
 
-end
-
+end

data/test/test_helper.rb

@@ -54,7 +54,6 @@ TestApp.routes.draw do
   jsonapi_resources :moons
   jsonapi_resources :preferences
 
-
   namespace :api do
     namespace :v1 do
       jsonapi_resources :authors
@@ -88,6 +87,20 @@ TestApp.routes.draw do
         jsonapi_links :tags, only: [:show, :create]
       end
     end
+
+    JSONAPI.configuration.route_format = :camelized_route
+    namespace :v4 do
+      jsonapi_resources :posts
+      jsonapi_resources :expense_entries
+      jsonapi_resources :iso_currencies
+    end
+    JSONAPI.configuration.route_format = :dasherized_route
+    namespace :v5 do
+      jsonapi_resources :posts
+      jsonapi_resources :expense_entries
+      jsonapi_resources :iso_currencies
+    end
+    JSONAPI.configuration.route_format = :underscored_route
   end
 end
 
@@ -108,6 +121,10 @@ class UpperCamelizedKeyFormatter < JSONAPI::KeyFormatter
     def format(key)
       super.camelize(:upper)
     end
+
+    def unformat(formatted_key)
+      formatted_key.to_s.underscore.to_sym
+    end
   end
 end
 

data/test/unit/resource/resource_test.rb

@@ -3,6 +3,10 @@ require File.expand_path('../../../fixtures/active_record', __FILE__)
 
 class ArticleResource < JSONAPI::Resource
   model_name 'Post'
+
+  def self.records(options)
+    options[:context].posts
+  end
 end
 
 class CatResource < JSONAPI::Resource
@@ -42,4 +46,34 @@ class ResourceTest < MiniTest::Unit::TestCase
     assert_kind_of(Hash, associations)
     assert_equal(associations.size, 2)
   end
+
+  def test_find_with_customized_base_records
+    author = Person.find(1)
+    posts = ArticleResource.find([], context: author).map(&:model)
+
+    assert(posts.include?(Post.find(1)))
+    refute(posts.include?(Post.find(3)))
+  end
+
+  def test_find_by_key_with_customized_base_records
+    author = Person.find(1)
+
+    post = ArticleResource.find_by_key(1, context: author).model
+    assert_equal(post, Post.find(1))
+
+    assert_raises JSONAPI::Exceptions::RecordNotFound do
+      ArticleResource.find_by_key(3, context: author).model
+    end
+  end
+
+  def test_find_by_keys_with_customized_base_records
+    author = Person.find(1)
+
+    posts = ArticleResource.find_by_keys([1, 2], context: author)
+    assert_equal(posts.length, 2)
+
+    assert_raises JSONAPI::Exceptions::RecordNotFound do
+      ArticleResource.find_by_keys([1, 3], context: author).model
+    end
+  end
 end

data/test/unit/serializer/serializer_test.rb

@@ -9,6 +9,12 @@ class SerializerTest < MiniTest::Unit::TestCase
     @fred = Person.find_by(name: 'Fred Reader')
 
     @expense_entry = ExpenseEntry.find(1)
+
+    JSONAPI.configuration.json_key_format = :camelized_key
+  end
+
+  def after_teardown
+    JSONAPI.configuration.json_key_format = :underscored_key
   end
 
   def test_serializer
@@ -28,7 +34,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           }
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post)))
   end
 
@@ -44,7 +50,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           }
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post),
         fields: {posts: [:id, :title, :author]}))
   end
@@ -78,7 +84,7 @@ class SerializerTest < MiniTest::Unit::TestCase
                    }]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post), include: [:author]))
   end
 
@@ -111,7 +117,7 @@ class SerializerTest < MiniTest::Unit::TestCase
                    }]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post),
         include: [:author],
         key_formatter: UnderscoredKeyFormatter))
@@ -179,7 +185,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           ]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post), include: [:comments, 'comments.tags']))
   end
 
@@ -225,7 +231,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           ]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post), include: ['comments.tags']))
   end
 
@@ -259,7 +265,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           ]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         PostResource.new(@post), include: ['author.comments']))
   end
 
@@ -299,7 +305,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           ]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PersonResource).serialize_to_hash(
         PersonResource.new(@fred), include: ['comments']))
   end
 
@@ -398,7 +404,7 @@ class SerializerTest < MiniTest::Unit::TestCase
           ]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         posts, include: ['comments', 'comments.tags']))
   end
 
@@ -482,7 +488,7 @@ class SerializerTest < MiniTest::Unit::TestCase
             }]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
         posts,
         include: ['comments', 'author', 'comments.tags', 'author.posts'],
         fields: {
@@ -520,7 +526,7 @@ class SerializerTest < MiniTest::Unit::TestCase
                    }]
         }
       },
-      JSONAPI::ResourceSerializer.new.serialize_to_hash(
+      JSONAPI::ResourceSerializer.new(ExpenseEntryResource).serialize_to_hash(
         ExpenseEntryResource.new(@expense_entry),
         include: ['iso_currency', 'employee'],
         fields: {people: [:id, :name, :email, :date_joined]}
@@ -529,7 +535,8 @@ class SerializerTest < MiniTest::Unit::TestCase
   end
 
   def test_serializer_empty_links_null_and_array
-    planet_hash = JSONAPI::ResourceSerializer.new.serialize_to_hash(PlanetResource.new(Planet.find(8)))
+    planet_hash = JSONAPI::ResourceSerializer.new(PlanetResource).serialize_to_hash(
+      PlanetResource.new(Planet.find(8)))
 
     assert_hash_equals(
       {
@@ -556,7 +563,7 @@ class SerializerTest < MiniTest::Unit::TestCase
       planets.push PlanetResource.new(planet)
     end
 
-    planet_hash = JSONAPI::ResourceSerializer.new.serialize_to_hash(
+    planet_hash = JSONAPI::ResourceSerializer.new(PlanetResource).serialize_to_hash(
       planets,
       include: ['planet_type'],
       fields: { planet_types: [:id, :name] }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-29 00:00:00.000000000 Z
+date: 2014-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler