jsonapi-resources 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6700d2a30e18dc6391ba4aa8bc0ecdd517e2fdfb
-  data.tar.gz: ad330dfe0d8fdc5da07d7ee40db08e892293296d
+  metadata.gz: 526bbf206d79bc7971772b890f0734ab2af6b426
+  data.tar.gz: 015940fbcc6439e1616bbfc538c63e213d5544da
 SHA512:
-  metadata.gz: 893a1947cd78da813d77e69c92dafbaac07b50c8dab2ab495ebdf49da50c082f8123c99361cf95793e606dd4916d140401566a4465829bf137aa1f86144589db
-  data.tar.gz: d00fb87cc0c3a787d28fb68bc1d8072b6dc30143108dc3672770b19704430126511bf0aa73d2b86434546812ff6a4d194d710eb521a6f9d88840d8faeeef59d6
+  metadata.gz: f9470953f1434a9ae0fff2de51f730cc0357369f7240b07a0edc7d948440b843e52e20f78e19dcf7e28f3b18a7ba8fd31a5136f53d9919603d47d8b1fe174201
+  data.tar.gz: 23b05b382b869d38a26937b9c9c2c8d75811543e456e6c37963d498b9f06d9e644ab5ca8318afcee4d6b27c84e379453037cef50dc28027cebb60a182a811212

data/.travis.yml

@@ -3,3 +3,4 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1
+  - 2.2

data/Gemfile

@@ -3,9 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 platforms :ruby do
-  # sqlite3 1.3.9 does not work with rubinius 2.2.5:
-  # https://github.com/sparklemotion/sqlite3-ruby/issues/122
-  gem 'sqlite3', '1.3.8'
+  gem 'sqlite3', '1.3.10'
 end
 
 platforms :jruby do

data/README.md

@@ -1,6 +1,6 @@
 # JSONAPI::Resources [![Build Status](https://secure.travis-ci.org/cerebris/jsonapi-resources.png?branch=master)](http://travis-ci.org/cerebris/jsonapi-resources)
 
-JSONAPI::Resources, or "JR", provides a framework for developing a server that complies with the [JSON API](http://jsonapi.org/) specification.
+`JSONAPI::Resources`, or "JR", provides a framework for developing a server that complies with the [JSON API](http://jsonapi.org/) specification.
 
 Like JSON API itself, JR's design is focused on the resources served by an API. JR needs little more than a definition of your resources, including their attributes and relationships, to make your server compliant with JSON API.
 
@@ -63,7 +63,7 @@ end
 
 This resource has 5 attributes: `:id`, `:name_first`, `:name_last`, `:email`, `:twitter`. By default these attributes must exist on the model that is handled by the resource.
 
-A resource object wraps a Ruby object, usually an ActiveModel record, which is available as the `@model` variable. This allows a resource's methods to access the underlying model.
+A resource object wraps a Ruby object, usually an `ActiveModel` record, which is available as the `@model` variable. This allows a resource's methods to access the underlying model.
 
 For example, a computed attribute for `full_name` could be defined as such:
 
@@ -102,7 +102,7 @@ class AuthorResource < JSONAPI::Resource
 end
 ```
 
-Context flows through from the controller and can be used to control the attributes based on the current user (or other value)).
+Context flows through from the controller and can be used to control the attributes based on the current user (or other value).
 
 ##### Creatable and Updateable Attributes
 
@@ -152,9 +152,9 @@ end
 
 ##### Attribute Formatting
 
-Attributes can have a Format. By default all attributes use the default formatter. If an attribute has the `format` option set the system will attempt to find a formatter based on this name. In the following example the `last_login_time` will be returned formatted to a certain time zone:
+Attributes can have a `Format`. By default all attributes use the default formatter. If an attribute has the `format` option set the system will attempt to find a formatter based on this name. In the following example the `last_login_time` will be returned formatted to a certain time zone:
 
-```
+```ruby
 class PersonResource < JSONAPI::Resource
   attributes :id, :name, :email
   attribute :last_login_time, format: :date_with_timezone
@@ -235,7 +235,7 @@ Examples:
 class ExpenseEntryResource < JSONAPI::Resource
   attributes :id, :cost, :transaction_date
 
-  has_one :currency, class_name: 'Currency', key: 'currency_code'
+  has_one :currency, class_name: 'Currency', foreign_key: 'currency_code'
   has_one :employee
 end
 ```
@@ -260,7 +260,7 @@ 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`, `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.
 
 ###### Customizing base records for finder methods
 
@@ -281,9 +281,9 @@ 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.
+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.
 
-For example to change how a
+This example shows how you can implement different approaches for different filters.
 
 ```ruby
 def apply_filter(records, filter, value)
@@ -332,7 +332,7 @@ 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.
+`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.
 
 For example:
 
@@ -362,6 +362,98 @@ class PeopleController < ApplicationController
 end
 ```
 
+#### Namespaces
+
+JSONAPI::Resources supports namespacing of controllers and resources. With namespacing you can version your API.
+
+If you namespace your controller it will require a namespaced resource.
+
+In the following example we have a `resource` that isn't namespaced, and one the has now been namespaced. There are slight differences between the two resources, as might be seen in a new version of an API:
+
+```ruby
+class PostResource < JSONAPI::Resource
+  attribute :id
+  attribute :title
+  attribute :body
+  attribute :subject
+
+  has_one :author, class_name: 'Person'
+  has_one :section
+  has_many :tags, acts_as_set: true
+  has_many :comments, acts_as_set: false
+  def subject
+    @model.title
+  end
+
+  filters :title, :author, :tags, :comments
+  filter :id
+end
+
+...
+
+module Api
+  module V1
+    class PostResource < JSONAPI::Resource
+      # V1 replaces the non-namespaced resource
+      # V1 no longer supports tags and now calls author 'writer'
+      attribute :id
+      attribute :title
+      attribute :body
+      attribute :subject
+
+      has_one :writer, foreign_key: 'author_id'
+      has_one :section
+      has_many :comments, acts_as_set: false
+
+      def subject
+        @model.title
+      end
+
+      filters :writer
+    end
+
+    class WriterResource < JSONAPI::Resource
+      attributes :id, :name, :email
+      model_name 'Person'
+      has_many :posts
+
+      filter :name
+    end
+  end
+end
+```
+
+The following controllers are used:
+
+```ruby
+class PostsController < JSONAPI::ResourceController
+end
+
+module Api
+  module V1
+    class PostsController < JSONAPI::ResourceController
+    end
+  end
+end
+```
+
+You will also need to namespace your routes:
+
+```ruby
+Rails.application.routes.draw do
+
+  jsonapi_resources :posts
+
+  namespace :api do
+    namespace :v1 do
+      jsonapi_resources :posts
+    end
+  end
+end
+```
+
+When a namespaced `resource` is used, any related `resources` must also be in the same namespace.
+
 #### Error codes
 
 Error codes are provided for each error object returned, based on the error. These errors are:
@@ -420,7 +512,7 @@ This returns results like this:
 }
 ```
 
-#### Serialize_to_hash method options
+#### serialize_to_hash method options
 
 The `serialize_to_hash` method also takes some optional parameters:
 
@@ -442,13 +534,16 @@ A hash of resource types and arrays of fields for each resource type.
 
 ```ruby
 post = Post.find(1)
-JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(PostResource.new(post),
-        include: ['comments','author','comments.tags','author.posts'],
-        fields: {
-                 people: [:id, :email, :comments],
-                 posts: [:id, :title, :author],
-                 tags: [:name],
-                 comments: [:id, :body, :post]})
+JSONAPI::ResourceSerializer.new(PostResource).serialize_to_hash(
+  PostResource.new(post),
+  include: ['comments','author','comments.tags','author.posts'],
+  fields: {
+    people: [:id, :email, :comments],
+    posts: [:id, :title, :author],
+    tags: [:name],
+    comments: [:id, :body, :post]
+  }
+)
 ```
 
 ##### `context`
@@ -461,7 +556,7 @@ JR has a couple of helper methods available to assist you with setting up routes
 
 ##### `jsonapi_resources`
 
-Like `resources` in ActionDispatch, `jsonapi_resources` provides resourceful routes mapping between HTTP verbs and URLs and controller actions. This will also setup mappings for relationship URLs for a resource's associations. For example
+Like `resources` in `ActionDispatch`, `jsonapi_resources` provides resourceful routes mapping between HTTP verbs and URLs and controller actions. This will also setup mappings for relationship URLs for a resource's associations. For example:
 
 ```ruby
 require 'jsonapi/routing_ext'
@@ -586,13 +681,13 @@ end
 
 You can also create your own Value Formatter. Value Formatters must be named with the `format` name followed by `ValueFormatter`, i.e. `DateWithTimezoneValueFormatter` and derive from `JSONAPI::ValueFormatter`. It is recommended that you create a directory for your formatters, called `formatters`.
 
-The `format` method is called by the ResourceSerializer as is serializing a resource. The format method takes the `raw_value`, and `context` parameters. `raw_value` is the value as read from the model, and `context` is the context of the current user/request. From this you can base the formatted version of the attribute current context.
+The `format` method is called by the `ResourceSerializer` as is serializing a resource. The format method takes the `raw_value`, and `context` parameters. `raw_value` is the value as read from the model, and `context` is the context of the current user/request. From this you can base the formatted version of the attribute current context.
 
 The `unformat` method is called when processing the request. Each incoming attribute (except `links`) are run through the `unformat` method. The `unformat` method takes the `value`, and `context` parameters. `value` is the value as it comes in on the request, and `context` is the context of the current user/request. This allows you process the incoming value to alter its state before it is stored in the model. By default no processing is applied.
 
 ###### Use a Different Default Value Formatter
 
-Another way to handle formatting is to set a different default value formatter. This will affect all attributes that do notw have a `format` set. You can do this by overriding the `default_attribute_options` method for a resource (or a base resource for a system wide change).
+Another way to handle formatting is to set a different default value formatter. This will affect all attributes that do not have a `format` set. You can do this by overriding the `default_attribute_options` method for a resource (or a base resource for a system wide change).
 
 ```ruby
   def default_attribute_options
@@ -623,7 +718,7 @@ 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.
+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.
 
 For example to use camel cased keys with an initial lowercase character (JSON's default) create an initializer and add the following:
 
@@ -634,7 +729,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`. Besides `UnderscoredKeyFormatter` and `CamelizedKeyFormatter` JR defines the `DasherizedKeyFormatter`. You can also create your own `KeyFormatter`, for example:
 
 ```ruby
 class UpperCamelizedKeyFormatter < JSONAPI::KeyFormatter

data/lib/jsonapi/formatter.rb

@@ -102,6 +102,15 @@ class DefaultValueFormatter < JSONAPI::ValueFormatter
   end
 end
 
+class IdValueFormatter < JSONAPI::ValueFormatter
+  class << self
+    def format(raw_value, context)
+      return if raw_value.nil?
+      raw_value.to_s
+    end
+  end
+end
+
 class UnderscoredRouteFormatter < JSONAPI::RouteFormatter
 end
 
@@ -127,4 +136,4 @@ class DasherizedRouteFormatter < JSONAPI::RouteFormatter
       formatted_route.to_s.underscore.to_sym
     end
   end
-end
+end

data/lib/jsonapi/request.rb

@@ -20,7 +20,7 @@ module JSONAPI
     end
 
     def setup(params)
-      @resource_klass ||= self.class.resource_for(params[:controller].split('/').last) if params[:controller]
+      @resource_klass ||= self.class.resource_for(params[:controller]) if params[:controller]
 
       unless params.nil?
         case params[:action]
@@ -77,7 +77,7 @@ module JSONAPI
         underscored_type = unformat_key(type)
         fields[type] = []
         begin
-          type_resource = self.class.resource_for(underscored_type)
+          type_resource = self.class.resource_for(@resource_klass.module_path + underscored_type.to_s)
         rescue NameError
           @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
         end
@@ -109,7 +109,7 @@ module JSONAPI
       association = resource_klass._association(association_name)
       if association
         unless include_parts.last.empty?
-          check_include(Resource.resource_for(association.class_name), include_parts.last.partition('.'))
+          check_include(Resource.resource_for(@resource_klass.module_path + association.class_name.to_s), include_parts.last.partition('.'))
         end
       else
         @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
@@ -219,13 +219,13 @@ module JSONAPI
         association = @resource_klass._association(param)
 
         if association.is_a?(JSONAPI::Association::HasOne)
-          checked_has_one_associations[param] = @resource_klass.resource_for(association.type).verify_key(value, @context)
+          checked_has_one_associations[param] = @resource_klass.resource_for(@resource_klass.module_path + association.type.to_s).verify_key(value, @context)
         elsif association.is_a?(JSONAPI::Association::HasMany)
           keys = []
           if value.is_a?(Array)
-            keys = @resource_klass.resource_for(association.type).verify_keys(value, @context)
+            keys = @resource_klass.resource_for(@resource_klass.module_path + association.type.to_s).verify_keys(value, @context)
           else
-            keys.push(@resource_klass.resource_for(association.type).verify_key(value, @context))
+            keys.push(@resource_klass.resource_for(@resource_klass.module_path + association.type.to_s).verify_key(value, @context))
           end
           checked_has_many_associations[param] = keys
         else

data/lib/jsonapi/resource.rb

@@ -398,6 +398,10 @@ module JSONAPI
         _allowed_filters.include?(filter)
       end
 
+      def module_path
+        @module_path ||= self.name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').downcase : ''
+      end
+
       private
 
       def check_reserved_resource_name(type, name)
@@ -441,8 +445,8 @@ module JSONAPI
 
           if @_associations[attr].is_a?(JSONAPI::Association::HasOne)
             define_method attr do
-              type_name = self.class._associations[attr].type
-              resource_class = self.class.resource_for(type_name)
+              type_name = self.class._associations[attr].type.to_s
+              resource_class = self.class.resource_for(self.class.module_path + type_name)
               if resource_class
                 associated_model = @model.send attr
                 return associated_model ? resource_class.new(associated_model, @context) : nil
@@ -450,8 +454,8 @@ module JSONAPI
             end unless method_defined?(attr)
           elsif @_associations[attr].is_a?(JSONAPI::Association::HasMany)
             define_method attr do
-              type_name = self.class._associations[attr].type
-              resource_class = self.class.resource_for(type_name)
+              type_name = self.class._associations[attr].type.to_s
+              resource_class = self.class.resource_for(self.class.module_path + type_name)
               resources = []
               if resource_class
                 associated_models = @model.send attr

data/lib/jsonapi/resource_controller.rb

@@ -104,7 +104,7 @@ module JSONAPI
     # :nocov:
 
     def resource_klass_name
-      @resource_klass_name ||= "#{self.class.name.demodulize.sub(/Controller$/, '').singularize}Resource"
+      @resource_klass_name ||= "#{self.class.name.sub(/Controller$/, '').singularize}Resource"
     end
 
     def setup_request

data/lib/jsonapi/resource_for.rb

@@ -9,7 +9,7 @@ module JSONAPI
       if RUBY_VERSION >= '2.0'
         def resource_for(type)
           resource_name = JSONAPI::Resource._resource_name_from_type(type)
-          Object.const_get resource_name if resource_name
+          Object.const_get(resource_name, false) if resource_name
         rescue NameError
           raise NameError, "JSONAPI: Could not find resource '#{type}'. (Class #{resource_name} not found)"
         end

data/lib/jsonapi/resource_serializer.rb

@@ -127,9 +127,15 @@ module JSONAPI
       end
 
       fields.each_with_object({}) do |name, hash|
-        hash[format_key(name)] = format_value(source.send(name),
-                                              source.class._attribute_options(name)[:format],
-                                              source)
+        format = source.class._attribute_options(name)[:format]
+        if format == :default && name == :id
+          format = 'id'
+        end
+        hash[format_key(name)] = format_value(
+          source.send(name),
+          format,
+          source
+        )
       end
     end
 
@@ -148,10 +154,9 @@ module JSONAPI
       included_associations = source.fetchable_fields & associations.keys
       associations.each_with_object({}) do |(name, association), hash|
         if included_associations.include? name
-          foreign_key = association.foreign_key
 
           if field_set.include?(name)
-            hash[format_key(name)] = source.send(foreign_key)
+            hash[format_key(name)] = foreign_key_value(source, association)
           end
 
           ia = requested_associations.is_a?(Hash) ? requested_associations[name] : nil
@@ -198,6 +203,18 @@ module JSONAPI
       return @linked_objects.key?(type) && @linked_objects[type].key?(id)
     end
 
+    # Extracts the foreign key value for an association.
+    def foreign_key_value(source, association)
+      foreign_key = association.foreign_key
+      value = source.send(foreign_key)
+
+      if association.is_a?(JSONAPI::Association::HasMany)
+        value.map { |value| IdValueFormatter.format(value, {}) }
+      elsif association.is_a?(JSONAPI::Association::HasOne)
+        IdValueFormatter.format(value, {})
+      end
+    end
+
     # Sets that an object should be included in the primary document of the response.
     def set_primary(type, id)
       type = format_key(type)

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = "0.0.14"
+    VERSION = "0.0.15"
   end
 end