jsonapi-resources 0.6.2 → 0.7.0

data/lib/jsonapi/resource_serializer.rb

@@ -1,7 +1,7 @@
 module JSONAPI
   class ResourceSerializer
 
-    attr_reader :url_generator, :key_formatter, :serialization_options, :primary_class_name
+    attr_reader :link_builder, :key_formatter, :serialization_options, :primary_class_name
 
     # initialize
     # Options can include
@@ -21,7 +21,7 @@ module JSONAPI
       @include            = options.fetch(:include, [])
       @include_directives = options[:include_directives]
       @key_formatter      = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
-      @url_generator      = generate_link_builder(primary_resource_klass, options)
+      @link_builder       = generate_link_builder(primary_resource_klass, options)
       @always_include_to_one_linkage_data = options.fetch(:always_include_to_one_linkage_data,
                                                           JSONAPI.configuration.always_include_to_one_linkage_data)
       @always_include_to_many_linkage_data = options.fetch(:always_include_to_many_linkage_data,
@@ -72,8 +72,8 @@ module JSONAPI
       }
     end
 
-    def find_link(query_params)
-      url_generator.query_link(query_params)
+    def query_link(query_params)
+      link_builder.query_link(query_params)
     end
 
     def format_key(key)
@@ -226,7 +226,7 @@ module JSONAPI
 
     def relationship_links(source)
       links = {}
-      links[:self] = url_generator.self_link(source)
+      links[:self] = link_builder.self_link(source)
 
       links
     end
@@ -237,11 +237,11 @@ module JSONAPI
     end
 
     def self_link(source, relationship)
-      url_generator.relationships_self_link(source, relationship)
+      link_builder.relationships_self_link(source, relationship)
     end
 
     def related_link(source, relationship)
-      url_generator.relationships_related_link(source, relationship)
+      link_builder.relationships_related_link(source, relationship)
     end
 
     def to_one_linkage(source, relationship)

data/lib/jsonapi/resources/version.rb

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

data/lib/jsonapi/response_document.rb

@@ -74,9 +74,9 @@ module JSONAPI
             result.pagination_params.each_pair do |link_name, params|
               if result.is_a?(JSONAPI::RelatedResourcesOperationResult)
                 relationship = result.source_resource.class._relationships[result._type.to_sym]
-                links[link_name] = serializer.url_generator.relationships_related_link(result.source_resource, relationship, query_params(params))
+                links[link_name] = serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
               else
-                links[link_name] = serializer.find_link(query_params(params))
+                links[link_name] = serializer.query_link(query_params(params))
               end
             end
         end

data/test/controllers/controller_test.rb

@@ -2183,7 +2183,7 @@ class PeopleControllerTest < ActionController::TestCase
     assert_equal json_response['data'][0]['attributes']['name'], 'Joe Author'
   end
 
-  def test_get_related_resource
+  def test_get_related_resource_no_namespace
     original_config = JSONAPI.configuration.dup
     JSONAPI.configuration.json_key_format = :dasherized_key
     JSONAPI.configuration.route_format = :underscored_key
@@ -2253,6 +2253,15 @@ class PeopleControllerTest < ActionController::TestCase
   end
 end
 
+class BooksControllerTest < ActionController::TestCase
+  def test_books_include_correct_type
+    $test_user = Person.find(1)
+    get :index, {filter: {id: '1'}, include: 'authors'}
+    assert_response :success
+    assert_equal 'authors', json_response['included'][0]['type']
+  end
+end
+
 class Api::V5::AuthorsControllerTest < ActionController::TestCase
   def test_get_person_as_author
     get :index, {filter: {id: '1'}}
@@ -2288,7 +2297,7 @@ class Api::V5::AuthorsControllerTest < ActionController::TestCase
       def meta(options)
         {
           fixed: 'Hardcoded value',
-          computed: "#{self.class._type.to_s}: #{options[:serializer].url_generator.self_link(self)}",
+          computed: "#{self.class._type.to_s}: #{options[:serializer].link_builder.self_link(self)}",
           computed_foo: options[:serialization_options][:foo],
           options[:serializer].format_key('test_key') => 'test value'
         }
@@ -2322,7 +2331,7 @@ class Api::V5::AuthorsControllerTest < ActionController::TestCase
         {
           custom_hash: {
             fixed: 'Hardcoded value',
-            computed: "#{self.class._type.to_s}: #{options[:serializer].url_generator.self_link(self)}",
+            computed: "#{self.class._type.to_s}: #{options[:serializer].link_builder.self_link(self)}",
             computed_foo: options[:serialization_options][:foo],
             options[:serializer].format_key('test_key') => 'test value'
           }
@@ -3100,19 +3109,17 @@ class Api::V1::MoonsControllerTest < ActionController::TestCase
    def test_get_related_resource
       get :get_related_resource, {crater_id: 'S56D', relationship: 'moon', source: "api/v1/craters"}
       assert_response :success
-      assert_hash_equals json_response,
-                              {
-                                data: {
-                                  id: "1",
-                                  type: "moons",
-                                  links: {self: "http://test.host/moons/1"},
-                                  attributes: {name: "Titan", description: "Best known of the Saturn moons."},
-                                  relationships: {
-                                    planet: {links: {self: "http://test.host/moons/1/relationships/planet", related: "http://test.host/moons/1/planet"}},
-                                    craters: {links: {self: "http://test.host/moons/1/relationships/craters", related: "http://test.host/moons/1/craters"}}}
-                                  }
-                                }
-
+      assert_hash_equals({
+                           data: {
+                             id: "1",
+                             type: "moons",
+                             links: {self: "http://test.host/api/v1/moons/1"},
+                             attributes: {name: "Titan", description: "Best known of the Saturn moons."},
+                             relationships: {
+                               planet: {links: {self: "http://test.host/api/v1/moons/1/relationships/planet", related: "http://test.host/api/v1/moons/1/planet"}},
+                               craters: {links: {self: "http://test.host/api/v1/moons/1/relationships/craters", related: "http://test.host/api/v1/moons/1/craters"}}}
+                             }
+                           }, json_response)
    end
 
    def test_get_related_resources_with_select_some_db_columns
@@ -3141,23 +3148,24 @@ class Api::V1::CratersControllerTest < ActionController::TestCase
   def test_get_related_resources
     get :get_related_resources, {moon_id: '1', relationship: 'craters', source: "api/v1/moons"}
     assert_response :success
-    assert_hash_equals json_response,
-                      {
-                        data: [
-                          {id:"A4D3",
-                           type:"craters",
-                           links:{self: "http://test.host/api/v1/craters/A4D3"},
-                           attributes:{code: "A4D3", description: "Small crater"},
-                           relationships:{moon: {links: {self: "http://test.host/api/v1/craters/A4D3/relationships/moon", related: "http://test.host/api/v1/craters/A4D3/moon"}}}
-                          },
-                          {id: "S56D",
-                           type: "craters",
-                           links:{self: "http://test.host/api/v1/craters/S56D"},
-                           attributes:{code: "S56D", description: "Very large crater"},
-                           relationships:{moon: {links: {self: "http://test.host/api/v1/craters/S56D/relationships/moon", related: "http://test.host/api/v1/craters/S56D/moon"}}}
-                          }
-                        ]
-                      }
+    assert_hash_equals({
+                         data: [
+                           {
+                             id:"A4D3",
+                             type:"craters",
+                             links:{self: "http://test.host/api/v1/craters/A4D3"},
+                             attributes:{code: "A4D3", description: "Small crater"},
+                             relationships:{moon: {links: {self: "http://test.host/api/v1/craters/A4D3/relationships/moon", related: "http://test.host/api/v1/craters/A4D3/moon"}}}
+                           },
+                           {
+                             id: "S56D",
+                             type: "craters",
+                             links:{self: "http://test.host/api/v1/craters/S56D"},
+                             attributes:{code: "S56D", description: "Very large crater"},
+                             relationships:{moon: {links: {self: "http://test.host/api/v1/craters/S56D/relationships/moon", related: "http://test.host/api/v1/craters/S56D/moon"}}}
+                           }
+                         ]
+                       }, json_response)
   end
 
   def test_show_relationship
@@ -3236,3 +3244,39 @@ class VehiclesControllerTest < ActionController::TestCase
     end
   end
 end
+
+class Api::V7::ClientsControllerTest < ActionController::TestCase
+  def test_get_namespaced_model_not_matching_resource_using_model_hint
+    get :index
+    assert_response :success
+    assert_equal 'clients', json_response['data'][0]['type']
+  ensure
+    Api::V7::ClientResource._model_hints['api/v7/customer'] = 'clients'
+  end
+
+  def test_get_namespaced_model_not_matching_resource_not_using_model_hint
+    Api::V7::ClientResource._model_hints.delete('api/v7/customer')
+    get :index
+    assert_response :success
+    assert_equal 'customers', json_response['data'][0]['type']
+  ensure
+    Api::V7::ClientResource._model_hints['api/v7/customer'] = 'clients'
+  end
+end
+
+class Api::V7::CustomersControllerTest < ActionController::TestCase
+  def test_get_namespaced_model_matching_resource
+    get :index
+    assert_response :success
+    assert_equal 'customers', json_response['data'][0]['type']
+  end
+end
+
+class Api::V7::CategoriesControllerTest < ActionController::TestCase
+  def test_uncaught_error_in_controller
+
+    get :show, {id: '1'}
+    assert_response 500
+    assert_match /Internal Server Error/, json_response['errors'][0]['detail']
+  end
+end

data/test/fixtures/active_record.rb

@@ -15,6 +15,7 @@ ActiveRecord::Schema.define do
     t.belongs_to :preferences
     t.integer    :hair_cut_id, index: true
     t.boolean    :book_admin, default: false
+    t.boolean    :special, default: false
     t.timestamps null: false
   end
 
@@ -134,6 +135,11 @@ ActiveRecord::Schema.define do
     t.boolean :banned, default: false
   end
 
+  create_table :book_authors, force: true do |t|
+    t.integer :book_id
+    t.integer :person_id
+  end
+
   create_table :book_comments, force: true do |t|
     t.text       :body
     t.belongs_to :book, index: true
@@ -254,6 +260,8 @@ class Person < ActiveRecord::Base
   belongs_to :hair_cut
   has_one :author_detail
 
+  has_and_belongs_to_many :books, join_table: :book_authors
+
   ### Validations
   validates :name, presence: true
   validates :date_joined, presence: true
@@ -408,6 +416,8 @@ end
 class Book < ActiveRecord::Base
   has_many :book_comments
   has_many :approved_book_comments, -> { where(approved: true) }, class_name: "BookComment"
+
+  has_and_belongs_to_many :authors, join_table: :book_authors, class_name: "Person"
 end
 
 class BookComment < ActiveRecord::Base
@@ -502,6 +512,16 @@ end
 class WebPage < ActiveRecord::Base
 end
 
+module Api
+  module V7
+    class Client < Customer
+    end
+
+    class Customer < Customer
+    end
+  end
+end
+
 ### OperationsProcessor
 class CountingActiveRecordOperationsProcessor < ActiveRecordOperationsProcessor
   after_find_operation do
@@ -545,6 +565,15 @@ class PostsController < BaseController
     head :forbidden
   end
 
+  def handle_exceptions(e)
+    case e
+      when PostsController::SpecialError
+        raise e
+      else
+        super(e)
+    end
+  end
+
   #called by test_on_server_error
   def self.set_callback_message(error)
     @callback_message = "Sent from method"
@@ -599,6 +628,12 @@ end
 class BoatsController < JSONAPI::ResourceController
 end
 
+class BooksController < JSONAPI::ResourceController
+end
+
+class AuthorsController < JSONAPI::ResourceController
+end
+
 ### CONTROLLERS
 module Api
   module V1
@@ -731,6 +766,12 @@ module Api
 
     class OrderFlagsController < JSONAPI::ResourceController
     end
+
+    class CategoriesController < JSONAPI::ResourceController
+    end
+
+    class ClientsController < JSONAPI::ResourceController
+    end
   end
 
   module V8
@@ -755,18 +796,27 @@ class PersonResource < BaseResource
   has_one :preferences
   has_one :hair_cut
 
-  filter :name
-
-  def self.verify_custom_filter(filter, values, context)
-    case filter
-      when :name
-        values.each do |value|
-          if value.length < 3
-            raise JSONAPI::Exceptions::InvalidFilterValue.new(filter, value)
-          end
-        end
+  filter :name, verify: ->(values, _context) {
+    values.each do |value|
+      if value.length < 3
+        raise JSONAPI::Exceptions::InvalidFilterValue.new(:name, value)
+      end
     end
-    return filter, values
+    return values
+  }
+end
+
+class SpecialBaseResource < BaseResource
+  abstract
+
+  model_hint model: Person, resource: :special_person
+end
+
+class SpecialPersonResource < SpecialBaseResource
+  model_name 'Person'
+
+  def self.records(options = {})
+    Person.where(special: true)
   end
 end
 
@@ -871,7 +921,18 @@ class PostResource < JSONAPI::Resource
   end
 
   filters :title, :author, :tags, :comments
-  filters :id, :ids
+  filter :id, verify: ->(values, context) {
+    verify_keys(values, context)
+    return values
+  }
+  filter :ids,
+         verify: ->(values, context) {
+           verify_keys(values, context)
+           return values
+         },
+         apply: -> (records, value, _options) {
+           records.where('id IN (?)', value)
+         }
 
   def self.updatable_fields(context)
     super(context) - [:author, :subject]
@@ -885,17 +946,6 @@ class PostResource < JSONAPI::Resource
     super(context) - [:id]
   end
 
-  def self.verify_custom_filter(filter, values, context = nil)
-    case filter
-      when :id
-        verify_keys(values, context)
-      when :ids #coerce :ids to :id
-        verify_keys(values, context)
-        return :id, values
-    end
-    return filter, values
-  end
-
   def self.verify_key(key, context = nil)
     super(key)
     raise JSONAPI::Exceptions::RecordNotFound.new(key) unless find_by_key(key, context: context)
@@ -1058,6 +1108,19 @@ class WebPageResource < JSONAPI::Resource
   attribute :link
 end
 
+class AuthorResource < JSONAPI::Resource
+  model_name 'Person'
+  attributes :name
+end
+
+class BookResource < JSONAPI::Resource
+  has_many :authors, class_name: 'Author'
+end
+
+class AuthorDetailResource < JSONAPI::Resource
+  attributes :author_stuff
+end
+
 module Api
   module V1
     class WriterResource < JSONAPI::Resource
@@ -1088,32 +1151,32 @@ module Api
       filters :writer
     end
 
-    PersonResource = PersonResource.dup
-    CommentResource = CommentResource.dup
-    TagResource = TagResource.dup
-    SectionResource = SectionResource.dup
-    IsoCurrencyResource = IsoCurrencyResource.dup
-    ExpenseEntryResource = ExpenseEntryResource.dup
-    BreedResource = BreedResource.dup
-    PlanetResource = PlanetResource.dup
-    PlanetTypeResource = PlanetTypeResource.dup
-    MoonResource = MoonResource.dup
-    CraterResource = CraterResource.dup
-    PreferencesResource = PreferencesResource.dup
-    EmployeeResource = EmployeeResource.dup
-    FriendResource = FriendResource.dup
-    HairCutResource = HairCutResource.dup
-    VehicleResource = VehicleResource.dup
-    CarResource = CarResource.dup
-    BoatResource = BoatResource.dup
+    class PersonResource < PersonResource; end
+    class CommentResource < CommentResource; end
+    class TagResource < TagResource; end
+    class SectionResource < SectionResource; end
+    class IsoCurrencyResource < IsoCurrencyResource; end
+    class ExpenseEntryResource < ExpenseEntryResource; end
+    class BreedResource < BreedResource; end
+    class PlanetResource < PlanetResource; end
+    class PlanetTypeResource < PlanetTypeResource; end
+    class MoonResource < MoonResource; end
+    class CraterResource < CraterResource; end
+    class PreferencesResource < PreferencesResource; end
+    class EmployeeResource < EmployeeResource; end
+    class FriendResource < FriendResource; end
+    class HairCutResource < HairCutResource; end
+    class VehicleResource < VehicleResource; end
+    class CarResource < CarResource; end
+    class BoatResource < BoatResource; end
   end
 end
 
 module Api
   module V2
-    PreferencesResource = PreferencesResource.dup
-    PersonResource = PersonResource.dup
-    PostResource = PostResource.dup
+    class PreferencesResource < PreferencesResource; end
+    class PersonResource < PersonResource; end
+    class PostResource < PostResource; end
 
     class BookResource < JSONAPI::Resource
       attribute :title
@@ -1132,24 +1195,18 @@ module Api
 
       has_many :aliased_comments, class_name: 'BookComments', relation_name: :approved_book_comments
 
-      filters :banned, :book_comments
-
-      class << self
-        def apply_filter(records, filter, value, options)
-          context = options[:context]
-          current_user = context ? context[:current_user] : nil
+      filters :book_comments
+      filter :banned, apply: ->(records, value, options) {
+        context = options[:context]
+        current_user = context ? context[:current_user] : nil
 
-          case filter
-            when :banned
-              # Only book admins my filter for banned books
-              if current_user && current_user.book_admin
-                return records.where('books.banned = ?', value[0] == 'true')
-              end
-            else
-              return super(records, filter, value)
-          end
+        # Only book admins my filter for banned books
+        if current_user && current_user.book_admin
+          records.where('books.banned = ?', value[0] == 'true')
         end
+      }
 
+      class << self
         def books
           Book.arel_table
         end
@@ -1178,7 +1235,15 @@ module Api
       has_one :book
       has_one :author, class_name: 'Person'
 
-      filters :approved, :book
+      filters :book
+      filter :approved, apply: ->(records, value, options) {
+        context = options[:context]
+        current_user = context ? context[:current_user] : nil
+
+        if current_user && current_user.book_admin
+          records.where(approved_comments(value[0] == 'true'))
+        end
+      }
 
       class << self
         def book_comments
@@ -1189,23 +1254,6 @@ module Api
           book_comments[:approved].eq(approved)
         end
 
-        def apply_filter(records, filter, value, options)
-          context = options[:context]
-          current_user = context ? context[:current_user] : nil
-
-          case filter
-            when :approved
-              # Only book admins my filter for unapproved comments
-              if current_user && current_user.book_admin
-                records.where(approved_comments(value[0] == 'true'))
-              end
-            else
-              #:nocov:
-              return super(records, filter, value)
-            #:nocov:
-          end
-        end
-
         def records(options = {})
           current_user = options[:context][:current_user]
           _model_class.for_user(current_user)
@@ -1217,17 +1265,17 @@ end
 
 module Api
   module V3
-    PostResource = PostResource.dup
-    PreferencesResource = PreferencesResource.dup
+    class PostResource < PostResource; end
+    class PreferencesResource < PreferencesResource; end
   end
 end
 
 module Api
   module V4
-    PostResource = PostResource.dup
-    ExpenseEntryResource = ExpenseEntryResource.dup
-    IsoCurrencyResource = IsoCurrencyResource.dup
-
+    class PostResource < PostResource; end
+    class PersonResource < PersonResource; end
+    class ExpenseEntryResource < ExpenseEntryResource; end
+    class IsoCurrencyResource < IsoCurrencyResource; end
 
     class BookResource < Api::V2::BookResource
       paginator :paged
@@ -1278,11 +1326,14 @@ module Api
       attributes :author_stuff
     end
 
-    PersonResource = PersonResource.dup
-    PostResource = PostResource.dup
-    ExpenseEntryResource = ExpenseEntryResource.dup
-    IsoCurrencyResource = IsoCurrencyResource.dup
-    EmployeeResource = EmployeeResource.dup
+    class PersonResource < PersonResource; end
+    class PostResource < PostResource; end
+    class TagResource < TagResource; end
+    class SectionResource < SectionResource; end
+    class CommentResource < CommentResource; end
+    class ExpenseEntryResource < ExpenseEntryResource; end
+    class IsoCurrencyResource < IsoCurrencyResource; end
+    class EmployeeResource < EmployeeResource; end
   end
 end
 
@@ -1349,10 +1400,32 @@ module Api
   end
 
   module V7
-    CustomerResource = V6::CustomerResource.dup
-    PurchaseOrderResource = V6::PurchaseOrderResource.dup
-    OrderFlagResource = V6::OrderFlagResource.dup
-    LineItemResource = V6::LineItemResource.dup
+    class PurchaseOrderResource < V6::PurchaseOrderResource; end
+    class OrderFlagResource < V6::OrderFlagResource; end
+    class LineItemResource < V6::LineItemResource; end
+
+    class CustomerResource < V6::CustomerResource
+      model_name 'Api::V7::Customer'
+      attribute :name
+      has_many :purchase_orders
+    end
+
+    class ClientResource < JSONAPI::Resource
+      model_name 'Api::V7::Customer'
+
+      attribute :name
+
+      has_many :purchase_orders
+    end
+
+    class CategoryResource < CategoryResource
+      attribute :name
+
+      # Raise exception for failure in controller
+      def name
+        fail "Something Exceptional Happened"
+      end
+    end
   end
 
   module V8
@@ -1392,7 +1465,10 @@ module Legacy
 end
 
 class FlatPostResource < JSONAPI::Resource
-  model_name "::Legacy::FlatPost"
+  model_name "Legacy::FlatPost", add_model_hint: false
+
+  model_hint model: "Legacy::FlatPost", resource: FlatPostResource
+
   attribute :title
 end