jsonapi-resources 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 885923e290e5ac1db4d49ed616f8f93b978edabe
-  data.tar.gz: f9ba1571591967f00bd09b274b2aae34b01153e0
+  metadata.gz: 233ad0db650881125288636b8fc022ccace40b01
+  data.tar.gz: 9c28dc89ef3f227398d6eecb9e4e274bcbd40d59
 SHA512:
-  metadata.gz: 305b0ae0b9f37ec829b178769044957f12f90c0272b69339b930deabac8f8f34bf310539597eeb01adc911c3bb897fd9aa60b52b3b077c9d925e926fa9fca157
-  data.tar.gz: d9716961f3daeb72d56ae12b37c42960f8dcd99042f8cf6d884d67081ceebfc1ae20510eef1d682fe504e726433ce443dc5007c6cd3da0a1065c1eef708948c3
+  metadata.gz: 57bca518364bab67494516f10166275905eeb115709113601eb96c691d6bbf1ee2d1db4aa0c17ec83093f746cc8d38f37d4f8f11e1b59b2a2ae68a35922585ca
+  data.tar.gz: 30c3a7125c2eccbcda03e0daa8adab71ac8542afa599d8787087ee9fa461aa1efaff9e95fc8544f6762b8405000d82cec1911adb6d3ec7e7a1e269f60bf387e2

data/README.md

@@ -1,4 +1,4 @@
-# JSONAPI::Resources [![Build Status](https://secure.travis-ci.org/cerebris/jsonapi-resources.png?branch=master)](http://travis-ci.org/cerebris/jsonapi-resources) [![Code Climate](https://codeclimate.com/github/cerebris/jsonapi-resources/badges/gpa.svg)](https://codeclimate.com/github/cerebris/jsonapi-resources)
+# JSONAPI::Resources [![Build Status](https://secure.travis-ci.org/cerebris/jsonapi-resources.svg?branch=master)](http://travis-ci.org/cerebris/jsonapi-resources) [![Code Climate](https://codeclimate.com/github/cerebris/jsonapi-resources/badges/gpa.svg)](https://codeclimate.com/github/cerebris/jsonapi-resources)
 
 [![Join the chat at https://gitter.im/cerebris/jsonapi-resources](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cerebris/jsonapi-resources?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -26,6 +26,7 @@ backed by ActiveRecord models or by custom objects.
     * [Filters] (#filters)
     * [Pagination] (#pagination)
     * [Included relationships (side-loading resources)] (#included-relationships-side-loading-resources)
+    * [Resource meta] (#resource-meta)
     * [Callbacks] (#callbacks)
   * [Controllers] (#controllers)
     * [Namespaces] (#namespaces)
@@ -186,7 +187,7 @@ end
 ##### Fetchable Attributes
 
 By default all attributes are assumed to be fetchable. The list of fetchable attributes can be filtered by overriding
-the `fetchable_fields` method.
+the `self.fetchable_fields` method.
 
 Here's an example that prevents guest users from seeing the `email` field:
 
@@ -196,7 +197,7 @@ class AuthorResource < JSONAPI::Resource
   model_name 'Person'
   has_many :posts
 
-  def fetchable_fields
+  def self.fetchable_fields(context)
     if (context[:current_user].guest)
       super - [:email]
     else
@@ -370,7 +371,7 @@ posts:
 
 ```ruby
 class PostResource < JSONAPI::Resource
-  attribute :title, :body
+  attributes :title, :body
 
   relationship :author, to: :one
 end
@@ -390,7 +391,7 @@ And here's the equivalent resources using the `has_one` and `has_many` methods:
 
 ```ruby
 class PostResource < JSONAPI::Resource
-  attribute :title, :body
+  attributes :title, :body
 
   has_one :author
 end
@@ -523,7 +524,7 @@ For example to allow a user to only retrieve his own posts you can do the follow
 
 ```ruby
 class PostResource < JSONAPI::Resource
-  attribute :title, :body
+  attributes :title, :body
 
   def self.records(options = {})
     context = options[:context]
@@ -793,6 +794,33 @@ Will get you the following payload by default:
 }
 ```
 
+#### Resource Meta
+
+Meta information can be included for each resource using the meta method in the resource declaration. For example:
+
+```ruby
+class BookResource < JSONAPI::Resource
+  attribute :title
+  attribute :isbn
+
+  def meta(options)
+    {
+      copyright: 'API Copyright 2015 - XYZ Corp.',
+      computed_copyright: options[:serialization_options][:copyright]
+      last_updated_at: _model.updated_at
+    }
+   end
+end
+
+```
+
+The `meta` method will be called for each resource instance. Override the `meta` method on a resource class to control
+the meta information for the resource. If a non empty hash is returned from `meta` this will be serialized. The `meta` 
+method is called with an `options` has. The `options` hash will contain the following:
+
+ * `:serializer` -> the serializer instance
+ * `:serialization_options` -> the contents of the `serialization_options` method on the controller.
+
 #### Callbacks
 
 `ActiveSupport::Callbacks` is used to provide callback functionality, so the behavior is very similar to what you may be
@@ -907,6 +935,9 @@ end
 
 Of course you are free to extend this as needed and override action handlers or other methods.
 
+
+###### Context
+
 The context that's used for serialization and resource configuration is set by the controller's `context` method.
 
 For example:
@@ -925,7 +956,21 @@ class PeopleController < ApplicationController
 end
 ```
 
-> __Note__: This gem [uses the filter chain to set up the request](https://github.com/cerebris/jsonapi-resources/issues/458#issuecomment-143297055). In some instances, variables that are set in the filter chain (such as `current_user`) may not be set at the right time. If this happens (i.e. `current_user` is `nil` in `context` but it's set properly everywhere else), you may want to have your authentication occur earlier in the filter chain, using `prepend_before_action` instead of `before_action`.
+###### Serialization Options
+
+Additional options can be passed to the serializer using the `serialization_options` method.
+
+For example:
+
+```ruby
+class ApplicationController < JSONAPI::ResourceController
+  def serialization_options
+    {copyright: 'Copyright 2015'}
+  end
+end
+```
+
+These `serialization_options` are passed to the `meta` method used to generate resource `meta` values.
 
 ##### ActsAsResourceController
 

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -2,56 +2,74 @@ require 'csv'
 
 module JSONAPI
   module ActsAsResourceController
-    extend ActiveSupport::Concern
 
-    included do
-      before_action :ensure_correct_media_type, only: [:create, :update, :create_relationship, :update_relationship]
-      append_before_action :setup_request
-      after_action :setup_response
+    def self.included(base)
+      base.extend ClassMethods
+      base.before_action :ensure_correct_media_type, only: [:create, :update, :create_relationship, :update_relationship]
+      base.cattr_reader :server_error_callbacks
     end
 
     def index
-      process_request_operations
+      process_request
     end
 
     def show
-      process_request_operations
+      process_request
     end
 
     def show_relationship
-      process_request_operations
+      process_request
     end
 
     def create
-      process_request_operations
+      process_request
     end
 
     def create_relationship
-      process_request_operations
+      process_request
     end
 
     def update_relationship
-      process_request_operations
+      process_request
     end
 
     def update
-      process_request_operations
+      process_request
     end
 
     def destroy
-      process_request_operations
+      process_request
     end
 
     def destroy_relationship
-      process_request_operations
+      process_request
     end
 
     def get_related_resource
-      process_request_operations
+      process_request
     end
 
     def get_related_resources
-      process_request_operations
+      process_request
+    end
+
+    def process_request
+      @request = JSONAPI::Request.new(params, context: context,
+                                      key_formatter: key_formatter,
+                                      server_error_callbacks: (self.class.server_error_callbacks || []))
+      unless @request.errors.empty?
+        render_errors(@request.errors)
+      else
+        operation_results = create_operations_processor.process(@request)
+        render_results(operation_results)
+      end
+
+      if response.body.size > 0
+        response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
+      end
+
+    rescue => e
+      handle_exceptions(e)
     end
 
     # set the operations processor in the configuration or override this to use another operations processor
@@ -85,25 +103,15 @@ module JSONAPI
       handle_exceptions(e)
     end
 
-    def setup_request
-      @request = JSONAPI::Request.new(params, context: context, key_formatter: key_formatter)
-
-      render_errors(@request.errors) unless @request.errors.empty?
-    rescue => e
-      handle_exceptions(e)
-    end
-
-    def setup_response
-      if response.body.size > 0
-        response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
-      end
-    end
-
     # override to set context
     def context
       {}
     end
 
+    def serialization_options
+      {}
+    end
+
     # Control by setting in an initializer:
     #     JSONAPI.configuration.json_key_format = :camelized_key
     #     JSONAPI.configuration.route = :camelized_route
@@ -159,17 +167,11 @@ module JSONAPI
         base_meta: base_meta,
         base_links: base_response_links,
         resource_serializer_klass: resource_serializer_klass,
-        request: @request
+        request: @request,
+        serialization_options: serialization_options
       )
     end
 
-    def process_request_operations
-      operation_results = create_operations_processor.process(@request)
-      render_results(operation_results)
-    rescue => e
-      handle_exceptions(e)
-    end
-
     # override this to process other exceptions
     # Note: Be sure to either call super(e) or handle JSONAPI::Exceptions::Error and raise unhandled exceptions
     def handle_exceptions(e)
@@ -183,10 +185,6 @@ module JSONAPI
       end
     end
 
-    def add_error_callbacks(callbacks)
-      @request.server_error_callbacks = callbacks || []
-    end
-
     # Pass in a methods or a block to be run when an exception is
     # caught that is not a JSONAPI::Exceptions::Error
     # Useful for additional logging or notification configuration that
@@ -194,8 +192,9 @@ module JSONAPI
     # Ignores whitelist exceptions from config
 
     module ClassMethods
+
       def on_server_error(*args, &callback_block)
-        callbacks = []
+        callbacks ||= []
 
         if callback_block
           callbacks << callback_block
@@ -211,8 +210,9 @@ module JSONAPI
           end
         end.compact
         callbacks += method_callbacks
-        append_before_action { add_error_callbacks(callbacks) }
+        self.class_variable_set :@@server_error_callbacks, callbacks
       end
+
     end
   end
 end

data/lib/jsonapi/exceptions.rb

@@ -297,7 +297,7 @@ module JSONAPI
       attr_reader :error_messages, :resource_relationships
 
       def initialize(resource)
-        @error_messages = resource._model.errors.messages
+        @error_messages = resource.model_error_messages
         @resource_relationships = resource.class._relationships.keys
         @key_formatter = JSONAPI.configuration.key_formatter
       end

data/lib/jsonapi/formatter.rb

@@ -76,7 +76,7 @@ end
 class DasherizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
     def format(key)
-      super.dasherize
+      super.underscore.dasherize
     end
 
     def unformat(formatted_key)

data/lib/jsonapi/mime_types.rb

@@ -5,5 +5,7 @@ end
 Mime::Type.register JSONAPI::MEDIA_TYPE, :api_json
 
 ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime::Type.lookup(JSONAPI::MEDIA_TYPE)] = lambda do |body|
-  JSON.parse(body)
+  data = JSON.parse(body)
+  data = {:_json => data} unless data.is_a?(Hash)
+  data.with_indifferent_access
 end

data/lib/jsonapi/operation.rb

@@ -79,9 +79,9 @@ module JSONAPI
     def apply
       key = @resource_klass.verify_key(@id, @context)
 
-      resource_record = resource_klass.find_by_key(key,
-                                                   context: @context,
-                                                   include_directives: @include_directives)
+      resource_record = @resource_klass.find_by_key(key,
+                                                    context: @context,
+                                                    include_directives: @include_directives)
 
       return JSONAPI::ResourceOperationResult.new(:ok, resource_record)
 

data/lib/jsonapi/request.rb

@@ -22,7 +22,7 @@ module JSONAPI
       @include_directives = nil
       @paginator = nil
       @id = nil
-      @server_error_callbacks = []
+      @server_error_callbacks = options.fetch(:server_error_callbacks, [])
 
       setup_action(@params)
     end

data/lib/jsonapi/resource.rb

@@ -107,9 +107,8 @@ module JSONAPI
       end
     end
 
-    # Override this on a resource instance to override the fetchable keys
     def fetchable_fields
-      self.class.fields
+      self.class.fetchable_fields(context)
     end
 
     # Override this on a resource to customize how the associated records
@@ -118,6 +117,19 @@ module JSONAPI
       _model.public_send relation_name
     end
 
+    def model_error_messages
+      _model.errors.messages
+    end
+
+    # Override this to return resource level meta data
+    # must return a hash, and if the hash is empty the meta section will not be serialized with the resource
+    # meta keys will be not be formatted with the key formatter for the serializer by default. They can however use the
+    # serializer's format_key and format_value methods if desired
+    # the _options hash will contain the serializer and the serialization_options
+    def meta(_options)
+      {}
+    end
+
     private
 
     def save
@@ -145,8 +157,14 @@ module JSONAPI
       end
 
       if defined? @model.save
-        saved = @model.save
-        fail JSONAPI::Exceptions::SaveFailed.new unless saved
+        saved = @model.save(validate: false)
+        unless saved
+          if @model.errors.present?
+            fail JSONAPI::Exceptions::ValidationErrors.new(self)
+          else
+            fail JSONAPI::Exceptions::SaveFailed.new
+          end
+        end
       else
         saved = true
       end
@@ -274,13 +292,37 @@ module JSONAPI
         check_reserved_resource_name(base._type, base.name)
       end
 
-      def resource_for(type)
-        resource_name = JSONAPI::Resource._resource_name_from_type(type)
-        resource = resource_name.safe_constantize if resource_name
-        if resource.nil?
-          fail NameError, "JSONAPI: Could not find resource '#{type}'. (Class #{resource_name} not found)"
+      def resource_for(resource_path)
+        unless @@resource_types.key? resource_path
+          klass_name = "#{resource_path.to_s.underscore.singularize}_resource".camelize
+          klass = (klass_name.safe_constantize or
+            fail NameError,
+                 "JSONAPI: Could not find resource '#{resource_path}'. (Class #{klass_name} not found)")
+          normalized_path = resource_path.rpartition('/').first
+          normalized_model = klass._model_name.to_s.gsub(/\A::/, '')
+          @@resource_types[resource_path] = {
+            resource: klass,
+            path: normalized_path,
+            model: normalized_model,
+          }
+        end
+        @@resource_types[resource_path][:resource]
+      end
+
+      def resource_for_model_path(model, path)
+        normalized_model = model.class.to_s.gsub(/\A::/, '')
+        normalized_path = path.gsub(/\/\z/, '')
+        resource = @@resource_types.find { |_, h|
+          h[:path] == normalized_path && h[:model] == normalized_model
+        }
+        if resource
+          resource.last[:resource]
+        else
+          #:nocov:#
+          fail NameError,
+               "JSONAPI: Could not find resource for model '#{path}#{normalized_model}'"
+          #:nocov:#
         end
-        resource
       end
 
       attr_accessor :_attributes, :_relationships, :_allowed_filters, :_type, :_paginator
@@ -385,6 +427,11 @@ module JSONAPI
       end
       # :nocov:
 
+      # Override in your resource to filter the fetchable keys
+      def fetchable_fields(_context = nil)
+        fields
+      end
+
       # Override in your resource to filter the updatable keys
       def updatable_fields(_context = nil)
         _updatable_relationships | _attributes.keys - [:id]
@@ -503,7 +550,7 @@ module JSONAPI
 
         resources = []
         records.each do |model|
-          resources.push resource_for(resource_type_for(model)).new(model, context)
+          resources.push resource_for_model_path(model, self.module_path).new(model, context)
         end
 
         resources
@@ -515,11 +562,7 @@ module JSONAPI
         records = apply_includes(records, options)
         model = records.where({_primary_key => key}).first
         fail JSONAPI::Exceptions::RecordNotFound.new(key) if model.nil?
-        resource_for(resource_type_for(model)).new(model, context)
-      end
-
-      def resource_type_for(model)
-        self.module_path + model.class.to_s.underscore
+        resource_for_model_path(model, self.module_path).new(model, context)
       end
 
       # Override this method if you want to customize the relation for
@@ -635,15 +678,6 @@ module JSONAPI
         !@_allowed_filters.nil? ? @_allowed_filters : { id: {} }
       end
 
-      def _resource_name_from_type(type)
-        class_name = @@resource_types[type]
-        if class_name.nil?
-          class_name = "#{type.to_s.underscore.singularize}_resource".camelize
-          @@resource_types[type] = class_name
-        end
-        return class_name
-      end
-
       def _paginator
         @_paginator ||= JSONAPI.configuration.default_paginator
       end
@@ -763,7 +797,7 @@ module JSONAPI
               define_method attr do |options = {}|
                 if relationship.polymorphic?
                   associated_model = public_send(associated_records_method_name)
-                  resource_klass = Resource.resource_for(self.class.resource_type_for(associated_model)) if associated_model
+                  resource_klass = self.class.resource_for_model_path(associated_model, self.class.module_path) if associated_model
                   return resource_klass.new(associated_model, @context) if resource_klass
                 else
                   resource_klass = relationship.resource_klass
@@ -816,7 +850,7 @@ module JSONAPI
               end
 
               return records.collect do |record|
-                resource_klass = Resource.resource_for(self.class.resource_type_for(record))
+                resource_klass = self.class.resource_for_model_path(record, self.class.module_path)
                 resource_klass.new(record, @context)
               end
             end unless method_defined?(attr)

data/lib/jsonapi/resource_serializer.rb

@@ -1,6 +1,9 @@
 module JSONAPI
   class ResourceSerializer
 
+    attr_reader :url_generator, :key_formatter, :serialization_options, :primary_class_name
+
+    # initialize
     # Options can include
     # include:
     #     Purpose: determines which objects will be side loaded with the source objects in a linked section
@@ -10,9 +13,7 @@ module JSONAPI
     #              relationship ids in the links section for a resource. Fields are global for a resource type.
     #     Example: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
     # key_formatter: KeyFormatter class to override the default configuration
-    # base_url: a string to prepend to generated resource links
-
-    attr_reader :url_generator
+    # serializer_options: additional options that will be passed to resource meta and links lambdas
 
     def initialize(primary_resource_klass, options = {})
       @primary_class_name = primary_resource_klass._type
@@ -25,6 +26,7 @@ module JSONAPI
                                                           JSONAPI.configuration.always_include_to_one_linkage_data)
       @always_include_to_many_linkage_data = options.fetch(:always_include_to_many_linkage_data,
                                                            JSONAPI.configuration.always_include_to_many_linkage_data)
+      @serialization_options = options.fetch(:serialization_options, {})
     end
 
     # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
@@ -74,6 +76,15 @@ module JSONAPI
       url_generator.query_link(query_params)
     end
 
+    def format_key(key)
+      @key_formatter.format(key)
+    end
+
+    def format_value(value, format)
+      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(format)
+      value_formatter.format(value)
+    end
+
     private
 
     # Process the primary source object(s). This will then serialize associated object recursively based on the
@@ -119,6 +130,10 @@ module JSONAPI
       relationships = relationship_data(source, include_directives)
       obj_hash['relationships'] = relationships unless relationships.nil? || relationships.empty?
 
+      meta = source.meta(custom_generation_options)
+      if meta.is_a?(Hash) && !meta.empty?
+        obj_hash['meta'] = meta
+      end
       obj_hash
     end
 
@@ -144,6 +159,13 @@ module JSONAPI
       end
     end
 
+    def custom_generation_options
+      {
+        serializer: self,
+        serialization_options: @serialization_options
+      }
+    end
+
     def relationship_data(source, include_directives)
       relationships = source.class._relationships
       requested = requested_fields(source.class)
@@ -313,15 +335,6 @@ module JSONAPI
       end
     end
 
-    def format_key(key)
-      @key_formatter.format(key)
-    end
-
-    def format_value(value, format)
-      value_formatter = JSONAPI::ValueFormatter.value_formatter_for(format)
-      value_formatter.format(value)
-    end
-
     def generate_link_builder(primary_resource_klass, options)
       LinkBuilder.new(
         base_url: options.fetch(:base_url, ''),

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.6.1'
+    VERSION = '0.6.2'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -36,7 +36,8 @@ module JSONAPI
         fields: @options[:fields],
         base_url: @options.fetch(:base_url, ''),
         key_formatter: @key_formatter,
-        route_formatter: @options.fetch(:route_formatter, JSONAPI.configuration.route_formatter)
+        route_formatter: @options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
+        serialization_options: @options.fetch(:serialization_options, {})
       )
     end
 

data/test/controllers/controller_test.rb

@@ -37,10 +37,10 @@ class PostsControllerTest < ActionController::TestCase
     JSONAPI.configuration.exception_class_whitelist = []
 
     @controller.class.instance_variable_set(:@callback_message, "none")
-    @controller.class.on_server_error do
+    BaseController.on_server_error do
       @controller.class.instance_variable_set(:@callback_message, "Sent from block")
     end
-    
+
     get :index
     assert_equal @controller.class.instance_variable_get(:@callback_message), "Sent from block"
 
@@ -54,7 +54,7 @@ class PostsControllerTest < ActionController::TestCase
   def test_on_server_error_method_callback_with_exception
     original_config = JSONAPI.configuration.dup
     JSONAPI.configuration.operations_processor = :error_raising
-    JSONAPI.configuration.exception_class_whitelist = [] 
+    JSONAPI.configuration.exception_class_whitelist = []
 
     #ignores methods that don't exist
     @controller.class.on_server_error :set_callback_message, :a_bogus_method
@@ -70,7 +70,7 @@ class PostsControllerTest < ActionController::TestCase
   end
 
   def test_on_server_error_callback_without_exception
-    
+
     callback = Proc.new { @controller.class.instance_variable_set(:@callback_message, "Sent from block") }
     @controller.class.on_server_error callback
     @controller.class.instance_variable_set(:@callback_message, "none")
@@ -1222,7 +1222,7 @@ class PostsControllerTest < ActionController::TestCase
 
     #check the relationship was created successfully
     assert_equal 1, Post.find(14).special_tags.count
-    before_tags = Post.find(14).tags.count 
+    before_tags = Post.find(14).tags.count
 
     delete :destroy_relationship, {post_id: 14, relationship: 'special_tags', data: [{type: 'tags', id: 2}]}
     assert_equal 0, Post.find(14).special_tags.count, "Relationship that matches URL relationship not destroyed"
@@ -2264,6 +2264,15 @@ class Api::V5::AuthorsControllerTest < ActionController::TestCase
     assert_equal nil, json_response['data'][0]['attributes']['email']
   end
 
+  def test_show_person_as_author
+    get :show, {id: '1'}
+    assert_response :success
+    assert_equal '1', json_response['data']['id']
+    assert_equal 'authors', json_response['data']['type']
+    assert_equal 'Joe Author', json_response['data']['attributes']['name']
+    assert_equal nil, json_response['data']['attributes']['email']
+  end
+
   def test_get_person_as_author_by_name_filter
     get :index, {filter: {name: 'thor'}}
     assert_response :success
@@ -2271,6 +2280,74 @@ class Api::V5::AuthorsControllerTest < ActionController::TestCase
     assert_equal '1', json_response['data'][0]['id']
     assert_equal 'Joe Author', json_response['data'][0]['attributes']['name']
   end
+
+  def test_meta_serializer_options
+    JSONAPI.configuration.json_key_format = :camelized_key
+
+    Api::V5::AuthorResource.class_eval do
+      def meta(options)
+        {
+          fixed: 'Hardcoded value',
+          computed: "#{self.class._type.to_s}: #{options[:serializer].url_generator.self_link(self)}",
+          computed_foo: options[:serialization_options][:foo],
+          options[:serializer].format_key('test_key') => 'test value'
+        }
+      end
+    end
+
+    get :show, {id: '1'}
+    assert_response :success
+    assert_equal '1', json_response['data']['id']
+    assert_equal 'Hardcoded value', json_response['data']['meta']['fixed']
+    assert_equal 'authors: http://test.host/api/v5/authors/1', json_response['data']['meta']['computed']
+    assert_equal 'bar', json_response['data']['meta']['computed_foo']
+    assert_equal 'test value', json_response['data']['meta']['testKey']
+
+  ensure
+    JSONAPI.configuration.json_key_format = :dasherized_key
+    Api::V5::AuthorResource.class_eval do
+      def meta(options)
+        # :nocov:
+        { }
+        # :nocov:
+      end
+    end
+  end
+
+  def test_meta_serializer_hash_data
+    JSONAPI.configuration.json_key_format = :camelized_key
+
+    Api::V5::AuthorResource.class_eval do
+      def meta(options)
+        {
+          custom_hash: {
+            fixed: 'Hardcoded value',
+            computed: "#{self.class._type.to_s}: #{options[:serializer].url_generator.self_link(self)}",
+            computed_foo: options[:serialization_options][:foo],
+            options[:serializer].format_key('test_key') => 'test value'
+          }
+        }
+      end
+    end
+
+    get :show, {id: '1'}
+    assert_response :success
+    assert_equal '1', json_response['data']['id']
+    assert_equal 'Hardcoded value', json_response['data']['meta']['custom_hash']['fixed']
+    assert_equal 'authors: http://test.host/api/v5/authors/1', json_response['data']['meta']['custom_hash']['computed']
+    assert_equal 'bar', json_response['data']['meta']['custom_hash']['computed_foo']
+    assert_equal 'test value', json_response['data']['meta']['custom_hash']['testKey']
+
+  ensure
+    JSONAPI.configuration.json_key_format = :dasherized_key
+    Api::V5::AuthorResource.class_eval do
+      def meta(options)
+        # :nocov:
+        { }
+        # :nocov:
+      end
+    end
+  end
 end
 
 class BreedsControllerTest < ActionController::TestCase
@@ -3158,4 +3235,4 @@ class VehiclesControllerTest < ActionController::TestCase
             }
     end
   end
-end
+end

data/test/fixtures/active_record.rb

@@ -530,8 +530,12 @@ end
 class PeopleController < JSONAPI::ResourceController
 end
 
-class PostsController < ActionController::Base
+class BaseController < ActionController::Base
   include JSONAPI::ActsAsResourceController
+end
+
+class PostsController < BaseController
+
   class SpecialError < StandardError; end
   class SubSpecialError < PostsController::SpecialError; end
 
@@ -683,6 +687,9 @@ module Api
 
   module V5
     class AuthorsController < JSONAPI::ResourceController
+      def serialization_options
+        {foo: 'bar'}
+      end
     end
 
     class PostsController < JSONAPI::ResourceController
@@ -1242,6 +1249,15 @@ module Api
 
       filter :name
 
+      def self.find_by_key(key, options = {})
+        context = options[:context]
+        records = records(options)
+        records = apply_includes(records, options)
+        model = records.where({_primary_key => key}).first
+        fail JSONAPI::Exceptions::RecordNotFound.new(key) if model.nil?
+        self.new(model, context)
+      end
+
       def self.find(filters, options = {})
         resources = []
 
@@ -1369,6 +1385,20 @@ module MyEngine
   end
 end
 
+module Legacy
+  class FlatPost < ActiveRecord::Base
+    self.table_name = "posts"
+  end
+end
+
+class FlatPostResource < JSONAPI::Resource
+  model_name "::Legacy::FlatPost"
+  attribute :title
+end
+
+class FlatPostsController < JSONAPI::ResourceController
+end
+
 ### PORO Data - don't do this in a production app
 $breed_data = BreedData.new
 $breed_data.add(Breed.new(0, 'persian'))

data/test/integration/requests/namespaced_model_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+class NamedspacedModelTest < ActionDispatch::IntegrationTest
+  def setup
+    JSONAPI.configuration.json_key_format = :underscored_key
+  end
+
+  def test_get_flat_posts
+    get '/flat_posts'
+    assert_equal 200, status
+    assert_equal "flat_posts", json_response["data"].first["type"]
+  end
+end

data/test/test_helper.rb

@@ -140,6 +140,7 @@ TestApp.routes.draw do
   jsonapi_resources :vehicles
   jsonapi_resources :cars
   jsonapi_resources :boats
+  jsonapi_resources :flat_posts
 
   namespace :api do
     namespace :v1 do

data/test/unit/formatters/dasherized_key_formatter_test.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+class DasherizedKeyFormatterTest < ActiveSupport::TestCase
+  def test_dasherize_camelize
+    formatted = DasherizedKeyFormatter.format("CarWash")
+    assert_equal formatted, "car-wash"
+  end
+end

data/test/unit/resource/resource_test.rb

@@ -8,6 +8,21 @@ class ArticleResource < JSONAPI::Resource
   end
 end
 
+class PostWithBadAfterSave < ActiveRecord::Base
+  self.table_name = 'posts'
+  after_save :do_some_after_save_stuff
+
+  def do_some_after_save_stuff
+    errors[:base] << 'Boom! Error added in after_save callback.'
+    raise ActiveRecord::RecordInvalid.new(self)
+  end
+end
+
+class ArticleWithBadAfterSaveResource < JSONAPI::Resource
+  model_name 'PostWithBadAfterSave'
+  attribute :title
+end
+
 class NoMatchResource < JSONAPI::Resource
 end
 
@@ -447,4 +462,13 @@ class ResourceTest < ActiveSupport::TestCase
     end
     assert_match "", err
   end
+
+  def test_correct_error_surfaced_if_validation_errors_in_after_save_callback
+    post = PostWithBadAfterSave.find(1)
+    post_resource = ArticleWithBadAfterSaveResource.new(post, nil)
+    err = assert_raises JSONAPI::Exceptions::ValidationErrors do
+      post_resource.replace_fields({:attributes => {:title => 'Some title'}})
+    end
+    assert_equal(err.error_messages[:base], ['Boom! Error added in after_save callback.'])
+  end
 end

data/test/unit/serializer/serializer_test.rb

@@ -1737,6 +1737,77 @@ class SerializerTest < ActionDispatch::IntegrationTest
     )
   end
 
+  def test_serializer_resource_meta_fixed_value
+    Api::V5::AuthorResource.class_eval do
+      def meta(options)
+        {
+          fixed: 'Hardcoded value',
+          computed: "#{self.class._type.to_s}: #{options[:serializer].url_generator.self_link(self)}"
+        }
+      end
+    end
+
+    serialized = JSONAPI::ResourceSerializer.new(
+      Api::V5::AuthorResource,
+      include: ['author_detail']
+    ).serialize_to_hash(Api::V5::AuthorResource.new(Person.find(1), nil))
+
+    assert_hash_equals(
+      {
+        data: {
+          type: 'authors',
+          id: '1',
+          attributes: {
+            name: 'Joe Author',
+          },
+          links: {
+            self: '/api/v5/authors/1'
+          },
+          relationships: {
+            posts: {
+              links: {
+                self: '/api/v5/authors/1/relationships/posts',
+                related: '/api/v5/authors/1/posts'
+              }
+            },
+            authorDetail: {
+              links: {
+                self: '/api/v5/authors/1/relationships/authorDetail',
+                related: '/api/v5/authors/1/authorDetail'
+              },
+              data: {type: 'authorDetails', id: '1'}
+            }
+          },
+          meta: {
+            fixed: 'Hardcoded value',
+            computed: 'authors: /api/v5/authors/1'
+          }
+        },
+        included: [
+          {
+            type: 'authorDetails',
+            id: '1',
+            attributes: {
+              authorStuff: 'blah blah'
+            },
+            links: {
+              self: '/api/v5/authorDetails/1'
+            }
+          }
+        ]
+      },
+      serialized
+    )
+  ensure
+    Api::V5::AuthorResource.class_eval do
+      def meta(options)
+        # :nocov:
+        { }
+        # :nocov:
+      end
+    end
+  end
+
   def test_serialize_model_attr
     @make = Make.first
     serialized = JSONAPI::ResourceSerializer.new(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -192,11 +192,13 @@ files:
 - test/helpers/functional_helpers.rb
 - test/helpers/value_matchers.rb
 - test/helpers/value_matchers_test.rb
+- test/integration/requests/namespaced_model_test.rb
 - test/integration/requests/request_test.rb
 - test/integration/routes/routes_test.rb
 - test/integration/sti_fields_test.rb
 - test/lib/generators/jsonapi/resource_generator_test.rb
 - test/test_helper.rb
+- test/unit/formatters/dasherized_key_formatter_test.rb
 - test/unit/jsonapi_request/jsonapi_request_test.rb
 - test/unit/operation/operations_processor_test.rb
 - test/unit/pagination/offset_paginator_test.rb
@@ -271,11 +273,13 @@ test_files:
 - test/helpers/functional_helpers.rb
 - test/helpers/value_matchers.rb
 - test/helpers/value_matchers_test.rb
+- test/integration/requests/namespaced_model_test.rb
 - test/integration/requests/request_test.rb
 - test/integration/routes/routes_test.rb
 - test/integration/sti_fields_test.rb
 - test/lib/generators/jsonapi/resource_generator_test.rb
 - test/test_helper.rb
+- test/unit/formatters/dasherized_key_formatter_test.rb
 - test/unit/jsonapi_request/jsonapi_request_test.rb
 - test/unit/operation/operations_processor_test.rb
 - test/unit/pagination/offset_paginator_test.rb