jsonapi-resources 0.10.0.beta3 → 0.10.0.beta4

data/lib/jsonapi/configuration.rb

@@ -1,6 +1,5 @@
 require 'jsonapi/formatter'
 require 'jsonapi/processor'
-require 'jsonapi/active_relation_resource_finder'
 require 'concurrent'
 
 module JSONAPI
@@ -10,6 +9,7 @@ module JSONAPI
                 :route_format,
                 :raise_if_parameters_not_allowed,
                 :warn_on_route_setup_issues,
+                :warn_on_missing_routes,
                 :default_allow_include_to_one,
                 :default_allow_include_to_many,
                 :allow_sort,
@@ -17,7 +17,6 @@ module JSONAPI
                 :default_paginator,
                 :default_page_size,
                 :maximum_page_size,
-                :resource_finder,
                 :default_processor_klass,
                 :use_text_errors,
                 :top_level_links_include_pagination,
@@ -59,6 +58,7 @@ module JSONAPI
       self.raise_if_parameters_not_allowed = true
 
       self.warn_on_route_setup_issues = true
+      self.warn_on_missing_routes = true
 
       # :none, :offset, :paged, or a custom paginator name
       self.default_paginator = :none
@@ -105,12 +105,6 @@ module JSONAPI
       self.always_include_to_one_linkage_data = false
       self.always_include_to_many_linkage_data = false
 
-      # ResourceFinder Mixin
-      # The default ResourceFinder is the ActiveRelationResourceFinder which provides
-      # access to ActiveRelation backed models. Custom ResourceFinders can be specified
-      # in order to support other ORMs.
-      self.resource_finder = JSONAPI::ActiveRelationResourceFinder
-
       # The default Operation Processor to use if one is not defined specifically
       # for a Resource.
       self.default_processor_klass = JSONAPI::Processor
@@ -225,10 +219,6 @@ module JSONAPI
       @default_processor_klass = default_processor_klass
     end
 
-    def resource_finder=(resource_finder)
-      @resource_finder = resource_finder
-    end
-
     def allow_include=(allow_include)
       ActiveSupport::Deprecation.warn('`allow_include` has been replaced by `default_allow_include_to_one` and `default_allow_include_to_many` options.')
       @default_allow_include_to_one = allow_include
@@ -273,6 +263,8 @@ module JSONAPI
 
     attr_writer :warn_on_route_setup_issues
 
+    attr_writer :warn_on_missing_routes
+
     attr_writer :use_relationship_reflection
 
     attr_writer :resource_cache

data/lib/jsonapi/include_directives.rb

@@ -4,14 +4,12 @@ module JSONAPI
     # For example ['posts.comments.tags']
     # will transform into =>
     # {
-    #   posts:{
-    #     include:true,
-    #     include_related:{
+    #   posts: {
+    #     include_related: {
     #       comments:{
-    #         include:true,
-    #         include_related:{
-    #           tags:{
-    #             include:true
+    #         include_related: {
+    #           tags: {
+    #             include_related: {}
     #           }
     #         }
     #       }
@@ -44,7 +42,7 @@ module JSONAPI
       path.segments.each do |segment|
         relationship_name = segment.relationship.name.to_sym
 
-        current[:include_related][relationship_name] ||= { include: true, include_related: {} }
+        current[:include_related][relationship_name] ||= { include_related: {} }
         current = current[:include_related][relationship_name]
       end
 

data/lib/jsonapi/link_builder.rb

@@ -2,32 +2,33 @@ module JSONAPI
   class LinkBuilder
     attr_reader :base_url,
                 :primary_resource_klass,
-                :route_formatter,
-                :engine_name
+                :engine,
+                :routes
 
     def initialize(config = {})
       @base_url               = config[:base_url]
       @primary_resource_klass = config[:primary_resource_klass]
-      @route_formatter        = config[:route_formatter]
-      @engine_name            = build_engine_name
+      @engine                 = build_engine
 
-      # Warning: These make LinkBuilder non-thread-safe. That's not a problem with the
-      # request-specific way it's currently used, though.
-      @resources_path_cache   = JSONAPI::NaiveCache.new do |source_klass|
-        formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
+      if engine?
+        @routes = @engine.routes
+      else
+        @routes = Rails.application.routes
       end
+
+      # ToDo: Use NaiveCache for values. For this we need to not return nils and create composite keys which work
+      # as efficient cache lookups. This could be an array of the [source.identifier, relationship] since the
+      # ResourceIdentity will compare equality correctly
     end
 
     def engine?
-      !!@engine_name
+      !!@engine
     end
 
     def primary_resources_url
-      if engine?
-        engine_primary_resources_url
-      else
-        regular_primary_resources_url
-      end
+      @primary_resources_url_cached ||= "#{ base_url }#{ primary_resources_path }"
+    rescue NoMethodError
+      warn "primary_resources_url for #{@primary_resource_klass} could not be generated" if JSONAPI.configuration.warn_on_missing_routes
     end
 
     def query_link(query_params)
@@ -35,26 +36,45 @@ module JSONAPI
     end
 
     def relationships_related_link(source, relationship, query_params = {})
-      url = "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
+      if relationship.parent_resource.singleton?
+        url_helper_name = singleton_related_url_helper_name(relationship)
+        url = call_url_helper(url_helper_name)
+      else
+        url_helper_name = related_url_helper_name(relationship)
+        url = call_url_helper(url_helper_name, source.id)
+      end
+
+      url = "#{ base_url }#{ url }"
       url = "#{ url }?#{ query_params.to_query }" if query_params.present?
       url
+    rescue NoMethodError
+      warn "related_link for #{relationship} could not be generated" if JSONAPI.configuration.warn_on_missing_routes
     end
 
     def relationships_self_link(source, relationship)
-      "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+      if relationship.parent_resource.singleton?
+        url_helper_name = singleton_relationship_self_url_helper_name(relationship)
+        url = call_url_helper(url_helper_name)
+      else
+        url_helper_name = relationship_self_url_helper_name(relationship)
+        url = call_url_helper(url_helper_name, source.id)
+      end
+
+      url = "#{ base_url }#{ url }"
+      url
+    rescue NoMethodError
+      warn "self_link for #{relationship} could not be generated" if JSONAPI.configuration.warn_on_missing_routes
     end
 
     def self_link(source)
-      if engine?
-        engine_resource_url(source)
-      else
-        regular_resource_url(source)
-      end
+      "#{ base_url }#{ resource_path(source) }"
+    rescue NoMethodError
+      warn "self_link for #{source.class} could not be generated" if JSONAPI.configuration.warn_on_missing_routes
     end
 
     private
 
-    def build_engine_name
+    def build_engine
       scopes = module_scopes_from_class(primary_resource_klass)
 
       begin
@@ -68,93 +88,96 @@ module JSONAPI
       end
     end
 
-    def engine_path_from_resource_class(klass)
-      path_name = engine_resources_path_name_from_class(klass)
-      engine_name.routes.url_helpers.public_send(path_name)
+    def call_url_helper(method, *args)
+      routes.url_helpers.public_send(method, args)
+    rescue NoMethodError => e
+      raise e
     end
 
-    def engine_primary_resources_path
-      engine_path_from_resource_class(primary_resource_klass)
+    def path_from_resource_class(klass)
+      url_helper_name = resources_url_helper_name_from_class(klass)
+      call_url_helper(url_helper_name)
     end
 
-    def engine_primary_resources_url
-      "#{ base_url }#{ engine_primary_resources_path }"
+    def resource_path(source)
+      url_helper_name = resource_url_helper_name_from_source(source)
+      if source.class.singleton?
+        call_url_helper(url_helper_name)
+      else
+        call_url_helper(url_helper_name, source.id)
+      end
     end
 
-    def engine_resource_path(source)
-      resource_path_name = engine_resource_path_name_from_source(source)
-      engine_name.routes.url_helpers.public_send(resource_path_name, source.id)
+    def primary_resources_path
+      path_from_resource_class(primary_resource_klass)
     end
 
-    def engine_resource_path_name_from_source(source)
-      scopes         = module_scopes_from_class(source.class)[1..-1]
-      base_path_name = scopes.map { |scope| scope.underscore }.join("_")
-      end_path_name  = source.class._type.to_s.singularize
-      [base_path_name, end_path_name, "path"].reject(&:blank?).join("_")
+    def url_helper_name_from_parts(parts)
+      (parts << "path").reject(&:blank?).join("_")
     end
 
-    def engine_resource_url(source)
-      "#{ base_url }#{ engine_resource_path(source) }"
-    end
+    def resources_path_parts_from_class(klass)
+      if engine?
+        scopes = module_scopes_from_class(klass)[1..-1]
+      else
+        scopes = module_scopes_from_class(klass)
+      end
 
-    def engine_resources_path_name_from_class(klass)
-      scopes         = module_scopes_from_class(klass)[1..-1]
       base_path_name = scopes.map { |scope| scope.underscore }.join("_")
       end_path_name  = klass._type.to_s
-
-      if base_path_name.blank?
-        "#{ end_path_name }_path"
-      else
-        "#{ base_path_name }_#{ end_path_name }_path"
-      end
+      [base_path_name, end_path_name]
     end
 
-    def format_route(route)
-      route_formatter.format(route)
+    def resources_url_helper_name_from_class(klass)
+      url_helper_name_from_parts(resources_path_parts_from_class(klass))
     end
 
-    def formatted_module_path_from_class(klass)
-      scopes = module_scopes_from_class(klass)
-
-      unless scopes.empty?
-        "/#{ scopes.map{ |scope| format_route(scope.to_s.underscore) }.compact.join('/') }/"
+    def resource_path_parts_from_class(klass)
+      if engine?
+        scopes = module_scopes_from_class(klass)[1..-1]
       else
-        "/"
+        scopes = module_scopes_from_class(klass)
       end
-    end
 
-    def module_scopes_from_class(klass)
-      klass.name.to_s.split("::")[0...-1]
+      base_path_name = scopes.map { |scope| scope.underscore }.join("_")
+      end_path_name  = klass._type.to_s.singularize
+      [base_path_name, end_path_name]
     end
 
-    def regular_resources_path(source_klass)
-      @resources_path_cache.get(source_klass)
+    def resource_url_helper_name_from_source(source)
+       url_helper_name_from_parts(resource_path_parts_from_class(source.class))
     end
 
-    def regular_primary_resources_path
-      regular_resources_path(primary_resource_klass)
+    def related_url_helper_name(relationship)
+      relationship_parts = resource_path_parts_from_class(relationship.parent_resource)
+      relationship_parts << relationship.name
+      url_helper_name_from_parts(relationship_parts)
     end
 
-    def regular_primary_resources_url
-      "#{ base_url }#{ regular_primary_resources_path }"
+    def singleton_related_url_helper_name(relationship)
+      relationship_parts = []
+      relationship_parts << relationship.name
+      relationship_parts += resource_path_parts_from_class(relationship.parent_resource)
+      url_helper_name_from_parts(relationship_parts)
     end
 
-    def regular_resource_path(source)
-      if source.is_a?(JSONAPI::CachedResponseFragment)
-        # :nocov:
-        "#{regular_resources_path(source.resource_klass)}/#{source.id}"
-        # :nocov:
-      else
-        "#{regular_resources_path(source.class)}/#{source.id}"
-      end
+    def relationship_self_url_helper_name(relationship)
+      relationship_parts = resource_path_parts_from_class(relationship.parent_resource)
+      relationship_parts << "relationships"
+      relationship_parts << relationship.name
+      url_helper_name_from_parts(relationship_parts)
     end
 
-    def regular_resource_url(source)
-      "#{ base_url }#{ regular_resource_path(source) }"
+    def singleton_relationship_self_url_helper_name(relationship)
+      relationship_parts = []
+      relationship_parts << "relationships"
+      relationship_parts << relationship.name
+      relationship_parts += resource_path_parts_from_class(relationship.parent_resource)
+      url_helper_name_from_parts(relationship_parts)
     end
 
-    def route_for_relationship(relationship)
-      format_route(relationship.name)
+    def module_scopes_from_class(klass)
+      klass.name.to_s.split("::")[0...-1]
     end
   end
 end

data/lib/jsonapi/operation_result.rb

@@ -100,7 +100,7 @@ module JSONAPI
     end
   end
 
-  class LinksObjectOperationResult < OperationResult
+  class RelationshipOperationResult < OperationResult
     attr_accessor :parent_resource, :relationship, :resource_ids
 
     def initialize(code, parent_resource, relationship, resource_ids, options = {})
@@ -112,7 +112,7 @@ module JSONAPI
 
     def to_hash(serializer = nil)
       if serializer
-        serializer.serialize_to_links_hash(parent_resource, relationship, resource_ids)
+        serializer.serialize_to_relationship_hash(parent_resource, relationship, resource_ids)
       else
         # :nocov:
         {}

data/lib/jsonapi/processor.rb

@@ -130,11 +130,11 @@ module JSONAPI
                                                        find_options,
                                                        nil)
 
-      return JSONAPI::LinksObjectOperationResult.new(:ok,
-                                                     parent_resource,
-                                                     resource_klass._relationship(relationship_type),
-                                                     resource_id_tree.fragments.keys,
-                                                     result_options)
+      return JSONAPI::RelationshipOperationResult.new(:ok,
+                                                      parent_resource,
+                                                      resource_klass._relationship(relationship_type),
+                                                      resource_id_tree.fragments.keys,
+                                                      result_options)
     end
 
     def show_related_resource
@@ -429,8 +429,7 @@ module JSONAPI
     def load_included(resource_klass, source_resource_id_tree, include_related, options)
       source_rids = source_resource_id_tree.fragments.keys
 
-      include_related.try(:each_pair) do |key, value|
-        next unless value[:include]
+      include_related.try(:each_key) do |key|
         relationship = resource_klass._relationship(key)
         relationship_name = relationship.name.to_sym
 

data/lib/jsonapi/relationship.rb

@@ -27,7 +27,9 @@ module JSONAPI
       @class_name = nil
       @inverse_relationship = nil
 
-      # Custom methods are reserved for use in resource finders. Not used in the default ActiveRelationResourceFinder
+      exclude_links(options.fetch(:exclude_links, :none))
+
+      # Custom methods are reserved for future use
       @custom_methods = options.fetch(:custom_methods, {})
     end
 
@@ -99,6 +101,27 @@ module JSONAPI
       @options[:readonly]
     end
 
+    def exclude_links(exclude)
+      case exclude
+        when :default, "default"
+          @_exclude_links = [:self, :related]
+        when :none, "none"
+          @_exclude_links = []
+        when Array
+          @_exclude_links = exclude.collect {|link| link.to_sym}
+        else
+          fail "Invalid exclude_links"
+      end
+    end
+
+    def _exclude_links
+      @_exclude_links ||= []
+    end
+
+    def exclude_link?(link)
+      _exclude_links.include?(link.to_sym)
+    end
+
     class ToOne < Relationship
       attr_reader :foreign_key_on
 
@@ -114,7 +137,7 @@ module JSONAPI
 
       def to_s
         # :nocov: useful for debugging
-        "#{parent_resource._type}.#{name} => (#{belongs_to? ? 'ToOne' : 'BelongsToOne'}) #{resource_klass._type}"
+        "#{parent_resource}.#{name}(#{belongs_to? ? 'BelongsToOne' : 'ToOne'})"
         # :nocov:
       end
 
@@ -164,7 +187,7 @@ module JSONAPI
 
       def to_s
         # :nocov: useful for debugging
-        "#{parent_resource._type}.#{name} => (ToMany) #{resource_klass._type}"
+        "#{parent_resource}.#{name}(ToMany)"
         # :nocov:
       end
 

data/lib/jsonapi/request_parser.rb

@@ -81,6 +81,7 @@ module JSONAPI
     end
 
     def setup_show_related_resource_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       source_klass = Resource.resource_klass_for(params.require(:source))
       source_id = source_klass.verify_key(params.require(source_klass._as_parent_key), @context)
 
@@ -102,6 +103,7 @@ module JSONAPI
     end
 
     def setup_index_related_resources_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       source_klass = Resource.resource_klass_for(params.require(:source))
       source_id = source_klass.verify_key(params.require(source_klass._as_parent_key), @context)
 
@@ -128,6 +130,7 @@ module JSONAPI
     end
 
     def setup_show_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       fields = parse_fields(resource_klass, params[:fields])
       include_directives = parse_include_directives(resource_klass, params[:include])
       id = params[:id]
@@ -144,6 +147,7 @@ module JSONAPI
     end
 
     def setup_show_relationship_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       relationship_type = params[:relationship]
       parent_key = params.require(resource_klass._as_parent_key)
       include_directives = parse_include_directives(resource_klass, params[:include])
@@ -191,6 +195,7 @@ module JSONAPI
     end
 
     def setup_create_relationship_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       parse_modify_relationship_action(:add, params, resource_klass)
     end
 
@@ -199,6 +204,7 @@ module JSONAPI
     end
 
     def setup_update_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       fields = parse_fields(resource_klass, params[:fields])
       include_directives = parse_include_directives(resource_klass, params[:include])
 
@@ -232,6 +238,7 @@ module JSONAPI
     end
 
     def setup_destroy_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       JSONAPI::Operation.new(
           :remove_resource,
           resource_klass,
@@ -240,6 +247,7 @@ module JSONAPI
     end
 
     def setup_destroy_relationship_action(params, resource_klass)
+      resolve_singleton_id(params, resource_klass)
       parse_modify_relationship_action(:remove, params, resource_klass)
     end
 
@@ -556,20 +564,39 @@ module JSONAPI
 
       links_object = parse_to_many_links_object(linkage)
 
-      # Since we do not yet support polymorphic to_many relationships we will raise an error if the type does not match the
-      # relationship's type.
-      # ToDo: Support Polymorphic relationships
-
       if links_object.length == 0
         add_result.call([])
       else
-        if links_object.length > 1 || !links_object.has_key?(unformat_key(relationship.type).to_s)
-          fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type], error_object_overrides)
-        end
+        if relationship.polymorphic?
+          polymorphic_results = []
+
+          links_object.each_pair do |type, keys|
+            type_name = unformat_key(type).to_s
+
+            relationship_resource_klass = resource_klass.resource_klass_for(relationship.class_name)
+            relationship_klass = relationship_resource_klass._model_class
 
-        links_object.each_pair do |type, keys|
-          relationship_resource = Resource.resource_klass_for(resource_klass.module_path + unformat_key(type).to_s)
-          add_result.call relationship_resource.verify_keys(keys, @context)
+            linkage_object_resource_klass = resource_klass.resource_klass_for(type_name)
+            linkage_object_klass = linkage_object_resource_klass._model_class
+
+            unless linkage_object_klass == relationship_klass || linkage_object_klass.in?(relationship_klass.subclasses)
+              fail JSONAPI::Exceptions::TypeMismatch.new(type_name)
+            end
+
+            relationship_ids = relationship_resource_klass.verify_keys(keys, @context)
+             polymorphic_results << { type: type, ids: relationship_ids }
+          end
+
+          add_result.call polymorphic_results
+        else
+          relationship_type = unformat_key(relationship.type).to_s
+
+          if links_object.length > 1 || !links_object.has_key?(relationship_type)
+            fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+          end
+
+          relationship_resource_klass = Resource.resource_klass_for(resource_klass.module_path + relationship_type)
+          add_result.call relationship_resource_klass.verify_keys(links_object[relationship_type], @context)
         end
       end
     end
@@ -695,6 +722,13 @@ module JSONAPI
       end
     end
 
+    def resolve_singleton_id(params, resource_klass)
+      if resource_klass.singleton? && params[:id].nil?
+        key = resource_klass.singleton_key(context)
+        params[:id] = key
+      end
+    end
+
     def format_key(key)
       @key_formatter.format(key)
     end