jsonapi-resources 0.9.6 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aca973f2c9c1164fc79771cc71b363be15d07159cbe8d2b273d63886fee30b05
-  data.tar.gz: cdd800dde1c3f08d6b7c1d6f904f7519f0168c7585a4a9e6b8d4ecf89e834e1c
+  metadata.gz: 3fc3aa84a3eee153f95a97c3d982e6fef51146998c0860ed4986f3c3911eb5c4
+  data.tar.gz: c75e87dad876b378b4aef634c7103b6399b171b8392831b1a0365146c82c02f9
 SHA512:
-  metadata.gz: 509137860c1e0a0a842a15ebeb580e229cc0636623ebc3d70aef2d752979bd066dc6ba2268bbdad483acdc1a5c25701c62eb9876b796effa80dd2e841fd4ef4d
-  data.tar.gz: b9dfc40e043337a749502f70f790e9280bf08e8a267bf0181e48522b27f58b8d1205cce28bc7e866adc6c566399cc313f3442a4aba86b1a6ef256e36b0f50873
+  metadata.gz: a35bf550f5cdd014236b4ec680526bc1041a024644ba83a036e1d57c2c7e837456f713ad7f3f4bca95bacf7cc50bc7588fcfdf3550c96eb3802bf086a48dac43
+  data.tar.gz: b322f9b3d22e6a3667f4b938559c3cf73af93fc54ad18311b443acafce36594cac7e2c8166c3b204e9ef50b07cb39f17b39edcbfa342d7a41434b359e7c9bd35

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -234,7 +234,7 @@ module JSONAPI
       end
 
       render_options[:location] = content[:data]["links"][:self] if (
-        response_doc.status == :created && content[:data].class != Array
+        response_doc.status == :created && content[:data].class != Array && content[:data]["links"]
       )
 
       # For whatever reason, `render` ignores :status and :content_type when :body is set.

data/lib/jsonapi/configuration.rb

@@ -8,6 +8,7 @@ module JSONAPI
                 :resource_key_type,
                 :route_format,
                 :raise_if_parameters_not_allowed,
+                :warn_on_missing_routes,
                 :allow_include,
                 :allow_sort,
                 :allow_filter,
@@ -51,6 +52,8 @@ module JSONAPI
 
       self.raise_if_parameters_not_allowed = true
 
+      self.warn_on_missing_routes = true
+
       # :none, :offset, :paged, or a custom paginator name
       self.default_paginator = :none
 
@@ -235,6 +238,8 @@ module JSONAPI
 
     attr_writer :raise_if_parameters_not_allowed
 
+    attr_writer :warn_on_missing_routes
+
     attr_writer :use_relationship_reflection
 
     attr_writer :resource_cache

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,118 +36,148 @@ 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
         unless scopes.empty?
           "#{ scopes.first.to_s.camelize }::Engine".safe_constantize
         end
-      rescue LoadError => e
+          # :nocov:
+      rescue LoadError => _e
         nil
+        # :nocov:
       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) }.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)
-      "#{regular_resources_path(source.class)}/#{source.id}"
+    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

@@ -53,7 +53,7 @@ module JSONAPI
     end
   end
 
-  class LinksObjectOperationResult < OperationResult
+  class RelationshipOperationResult < OperationResult
     attr_accessor :parent_resource, :relationship
 
     def initialize(code, parent_resource, relationship, options = {})

data/lib/jsonapi/processor.rb

@@ -136,9 +136,9 @@ module JSONAPI
 
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
-      return JSONAPI::LinksObjectOperationResult.new(:ok,
-                                                     parent_resource,
-                                                     resource_klass._relationship(relationship_type))
+      return JSONAPI::RelationshipOperationResult.new(:ok,
+                                                      parent_resource,
+                                                      resource_klass._relationship(relationship_type))
     end
 
     def show_related_resource

data/lib/jsonapi/relationship.rb

@@ -14,6 +14,8 @@ module JSONAPI
       @polymorphic = options.fetch(:polymorphic, false) == true
       @always_include_linkage_data = options.fetch(:always_include_linkage_data, false) == true
       @eager_load_on_include = options.fetch(:eager_load_on_include, true) == true
+
+      exclude_links(options.fetch(:exclude_links, :none))
     end
 
     alias_method :polymorphic?, :polymorphic
@@ -60,6 +62,27 @@ module JSONAPI
       false
     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
 
@@ -70,6 +93,12 @@ module JSONAPI
         @foreign_key_on = options.fetch(:foreign_key_on, :self)
       end
 
+      def to_s
+        # :nocov:
+        "#{parent_resource}.#{name}(#{belongs_to? ? 'BelongsToOne' : 'ToOne'})"
+        # :nocov:
+      end
+
       def belongs_to?
         foreign_key_on == :self
       end
@@ -89,6 +118,12 @@ module JSONAPI
         @reflect = options.fetch(:reflect, true) == true
         @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type.to_s.singularize.to_sym) if parent_resource
       end
+
+      def to_s
+        # :nocov:
+        "#{parent_resource}.#{name}(ToMany)"
+        # :nocov:
+      end
     end
   end
 end

data/lib/jsonapi/request_parser.rb

@@ -52,6 +52,7 @@ module JSONAPI
     end
 
     def setup_get_related_resource_action(params)
+      resolve_singleton_id(params)
       initialize_source(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
@@ -63,6 +64,7 @@ module JSONAPI
     end
 
     def setup_get_related_resources_action(params)
+      resolve_singleton_id(params)
       initialize_source(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
@@ -74,6 +76,7 @@ module JSONAPI
     end
 
     def setup_show_action(params)
+      resolve_singleton_id(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
       parse_filters(params[:filter])
@@ -83,6 +86,7 @@ module JSONAPI
     end
 
     def setup_show_relationship_action(params)
+      resolve_singleton_id(params)
       add_show_relationship_operation(params[:relationship], params.require(@resource_klass._as_parent_key))
     end
 
@@ -93,24 +97,29 @@ module JSONAPI
     end
 
     def setup_create_relationship_action(params)
+      resolve_singleton_id(params)
       parse_modify_relationship_action(params, :add)
     end
 
     def setup_update_relationship_action(params)
+      resolve_singleton_id(params)
       parse_modify_relationship_action(params, :update)
     end
 
     def setup_update_action(params)
+      resolve_singleton_id(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
       parse_replace_operation(params.require(:data), params[:id])
     end
 
     def setup_destroy_action(params)
+      resolve_singleton_id(params)
       parse_remove_operation(params)
     end
 
     def setup_destroy_relationship_action(params)
+      resolve_singleton_id(params)
       parse_modify_relationship_action(params, :remove)
     end
 
@@ -694,7 +703,8 @@ module JSONAPI
     end
 
     def parse_replace_operation(data, keys)
-      parse_single_replace_operation(data, [keys], id_key_presence_check_required: keys.present?)
+      parse_single_replace_operation(data, [keys],
+                                     id_key_presence_check_required: keys.present? && !@resource_klass.singleton?)
     rescue JSONAPI::Exceptions::Error => e
       @errors.concat(e.errors)
     end
@@ -725,6 +735,13 @@ module JSONAPI
       end
     end
 
+    def resolve_singleton_id(params)
+      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

data/lib/jsonapi/resource.rb

@@ -435,6 +435,8 @@ module JSONAPI
         subclass.abstract(false)
         subclass.immutable(false)
         subclass.caching(false)
+        subclass.singleton(singleton?, (_singleton_options.dup || {}))
+        subclass.exclude_links(_exclude_links)
         subclass._attributes = (_attributes || {}).dup
 
         subclass._model_hints = (_model_hints || {}).dup
@@ -606,6 +608,19 @@ module JSONAPI
         _model_hints[model.to_s.gsub('::', '/').underscore] = resource_type.to_s
       end
 
+      def singleton(*attrs)
+        @_singleton = (!!attrs[0] == attrs[0]) ? attrs[0] : true
+        @_singleton_options = attrs.extract_options!
+      end
+
+      def _singleton_options
+        @_singleton_options ||= {}
+      end
+
+      def singleton?
+        @_singleton ||= false
+      end
+
       def filters(*attrs)
         @_allowed_filters.merge!(attrs.inject({}) { |h, attr| h[attr] = {}; h })
       end
@@ -908,6 +923,24 @@ module JSONAPI
         @_resource_key_type ||= JSONAPI.configuration.resource_key_type
       end
 
+      # override to all resolution of masked ids to actual ids. Because singleton routes do not specify the id this
+      # will be needed to allow lookup of singleton resources. Alternately singleton resources can override
+      # `verify_key`
+      def singleton_key(context)
+        if @_singleton_options && @_singleton_options[:singleton_key]
+          strategy = @_singleton_options[:singleton_key]
+          case strategy
+            when Proc
+              key = strategy.call(context)
+            when Symbol, String
+              key = send(strategy, context)
+            else
+              raise "singleton_key must be a proc or function name"
+          end
+        end
+        key
+      end
+
       def verify_key(key, context = nil)
         key_type = resource_key_type
 
@@ -1032,6 +1065,27 @@ module JSONAPI
         !@immutable
       end
 
+      def exclude_links(exclude)
+        case exclude
+          when :default, "default"
+            @_exclude_links = [:self]
+          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
+
       def caching(val = true)
         @caching = val
       end

data/lib/jsonapi/resource_serializer.rb

@@ -90,20 +90,19 @@ module JSONAPI
       primary_hash
     end
 
-    def serialize_to_links_hash(source, requested_relationship)
+    def serialize_to_relationship_hash(source, requested_relationship)
       if requested_relationship.is_a?(JSONAPI::Relationship::ToOne)
         data = to_one_linkage(source, requested_relationship)
       else
         data = to_many_linkage(source, requested_relationship)
       end
 
-      {
-        links: {
-          self: self_link(source, requested_relationship),
-          related: related_link(source, requested_relationship)
-        },
-        data: data
-      }
+      rel_hash = { 'data': data }
+
+      links = default_relationship_links(source, requested_relationship)
+      rel_hash['links'] = links unless links.blank?
+
+      rel_hash
     end
 
     def query_link(query_params)
@@ -133,7 +132,6 @@ module JSONAPI
         supplying_attribute_fields: supplying_attribute_fields(resource_klass).sort,
         supplying_relationship_fields: supplying_relationship_fields(resource_klass).sort,
         link_builder_base_url: link_builder.base_url,
-        route_formatter_class: link_builder.route_formatter.uncached.class.name,
         key_formatter_class: key_formatter.uncached.class.name,
         always_include_to_one_linkage_data: always_include_to_one_linkage_data,
         always_include_to_many_linkage_data: always_include_to_many_linkage_data
@@ -152,7 +150,7 @@ module JSONAPI
         obj_hash['attributes'] = source.attributes_json if source.attributes_json
 
         relationships = cached_relationships_hash(source, include_directives)
-        obj_hash['relationships'] = relationships unless relationships.empty?
+        obj_hash['relationships'] = relationships unless relationships.blank?
 
         obj_hash['meta'] = source.meta_json if source.meta_json
       else
@@ -173,7 +171,7 @@ module JSONAPI
         obj_hash['attributes'] = attributes unless attributes.empty?
 
         relationships = relationships_hash(source, fetchable_fields, include_directives)
-        obj_hash['relationships'] = relationships unless relationships.nil? || relationships.empty?
+        obj_hash['relationships'] = relationships unless relationships.blank?
 
         meta = meta_hash(source)
         obj_hash['meta'] = meta unless meta.empty?
@@ -251,7 +249,9 @@ module JSONAPI
 
     def links_hash(source)
       links = custom_links_hash(source)
-      links[:self] = link_builder.self_link(source) unless links.key?(:self)
+      if !links.key?('self') && !source.class.exclude_link?(:self)
+        links['self'] = link_builder.self_link(source)
+      end
       links.compact
     end
 
@@ -289,7 +289,8 @@ module JSONAPI
 
         options = { filters: ia && ia[:include_filters] || {} }
         if field_set.include?(name)
-          hash[format_key(name)] = link_object(source, relationship, include_linkage)
+          ro = relationship_object(source, relationship, include_linkage)
+          hash[format_key(name)] = ro unless ro.blank?
         end
 
         # If the object has been serialized once it will be in the related objects list,
@@ -381,6 +382,13 @@ module JSONAPI
       link_builder.relationships_related_link(source, relationship)
     end
 
+    def default_relationship_links(source, relationship)
+      links = {}
+      links['self'] = self_link(source, relationship) unless relationship.exclude_link?(:self)
+      links['related'] = related_link(source, relationship) unless relationship.exclude_link?(:related)
+      links.compact
+    end
+
     def to_one_linkage(source, relationship)
       linkage_id = foreign_key_value(source, relationship)
       linkage_type = format_key(relationship.type_for_source(source))
@@ -428,31 +436,32 @@ module JSONAPI
       linkage
     end
 
-    def link_object_to_one(source, relationship, include_linkage)
+    def relationship_object_to_one(source, relationship, include_linkage)
       include_linkage = include_linkage | @always_include_to_one_linkage_data | relationship.always_include_linkage_data
-      link_object_hash = {}
-      link_object_hash[:links] = {}
-      link_object_hash[:links][:self] = self_link(source, relationship)
-      link_object_hash[:links][:related] = related_link(source, relationship)
-      link_object_hash[:data] = to_one_linkage(source, relationship) if include_linkage
-      link_object_hash
+      relationship_object_hash = {}
+
+      links = default_relationship_links(source, relationship)
+
+      relationship_object_hash['links'] = links unless links.blank?
+      relationship_object_hash[:data] = to_one_linkage(source, relationship) if include_linkage
+      relationship_object_hash
     end
 
-    def link_object_to_many(source, relationship, include_linkage)
+    def relationship_object_to_many(source, relationship, include_linkage)
       include_linkage = include_linkage | relationship.always_include_linkage_data
-      link_object_hash = {}
-      link_object_hash[:links] = {}
-      link_object_hash[:links][:self] = self_link(source, relationship)
-      link_object_hash[:links][:related] = related_link(source, relationship)
-      link_object_hash[:data] = to_many_linkage(source, relationship) if include_linkage
-      link_object_hash
+      relationship_object_hash = {}
+
+      links = default_relationship_links(source, relationship)
+      relationship_object_hash['links'] = links unless links.blank?
+      relationship_object_hash[:data] = to_many_linkage(source, relationship) if include_linkage
+      relationship_object_hash
     end
 
-    def link_object(source, relationship, include_linkage = false)
+    def relationship_object(source, relationship, include_linkage = false)
       if relationship.is_a?(JSONAPI::Relationship::ToOne)
-        link_object_to_one(source, relationship, include_linkage)
+        relationship_object_to_one(source, relationship, include_linkage)
       elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-        link_object_to_many(source, relationship, include_linkage)
+        relationship_object_to_many(source, relationship, include_linkage)
       end
     end
 
@@ -528,7 +537,6 @@ module JSONAPI
     def generate_link_builder(primary_resource_klass, options)
       LinkBuilder.new(
         base_url: options.fetch(:base_url, ''),
-        route_formatter: options.fetch(:route_formatter, JSONAPI.configuration.route_formatter),
         primary_resource_klass: primary_resource_klass,
       )
     end

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.9.6'
+    VERSION = '0.9.7'
   end
 end

data/lib/jsonapi/response_document.rb

@@ -64,14 +64,19 @@ module JSONAPI
 
         # Build pagination links
         if result.is_a?(JSONAPI::ResourcesOperationResult) || result.is_a?(JSONAPI::RelatedResourcesOperationResult)
-            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.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
-              else
-                links[link_name] = @serializer.query_link(query_params(params))
+          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]
+              unless relationship.exclude_link?(link_name)
+                link = @serializer.link_builder.relationships_related_link(result.source_resource, relationship, query_params(params))
+              end
+            else
+              unless @serializer.link_builder.primary_resource_klass.exclude_link?(link_name)
+                link = @serializer.link_builder.query_link(query_params(params))
               end
             end
+            links[link_name] = link unless link.blank?
+          end
         end
       end
 
@@ -109,9 +114,9 @@ module JSONAPI
             @serializer.serialize_to_hash(result.resource)
           when JSONAPI::ResourcesOperationResult
             @serializer.serialize_to_hash(result.resources)
-          when JSONAPI::LinksObjectOperationResult
-            @serializer.serialize_to_links_hash(result.parent_resource,
-                                               result.relationship)
+          when JSONAPI::RelationshipOperationResult
+            @serializer.serialize_to_relationship_hash(result.parent_resource,
+                                                       result.relationship)
           when JSONAPI::OperationResult
             {}
           end

data/lib/jsonapi/routing_ext.rb

@@ -20,6 +20,10 @@ module ActionDispatch
           @resource_type = resources.first
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
 
+          unless res.singleton?
+            warn "Singleton routes created for non singleton resource #{res}. Links may not be generated correctly."
+          end
+
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
           options.merge!(res.routing_resource_options)
@@ -80,6 +84,10 @@ module ActionDispatch
           @resource_type = resources.first
           res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
 
+          if res.singleton?
+            warn "Singleton resource #{res} should use `jsonapi_resource` instead."
+          end
+
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
           options.merge!(res.routing_resource_options)
@@ -153,19 +161,23 @@ module ActionDispatch
           methods = links_methods(options)
 
           if methods.include?(:show)
-            match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+            match "relationships/#{formatted_relationship_name}",
+                  controller: options[:controller],
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
             if methods.include?(:update)
-              match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+              match "relationships/#{formatted_relationship_name}",
+                    controller: options[:controller],
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
-              match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+              match "relationships/#{formatted_relationship_name}",
+                    controller: options[:controller],
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
@@ -182,23 +194,24 @@ module ActionDispatch
 
           if methods.include?(:show)
             match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
             if methods.include?(:create)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
+                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
             end
 
             if methods.include?(:update)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                          action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
@@ -219,9 +232,10 @@ module ActionDispatch
             options[:controller] ||= related_resource._type.to_s
           end
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resource', via: [:get]
+          match formatted_relationship_name, controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'get_related_resource', via: [:get],
+                as: relationship_name
         end
 
         def jsonapi_related_resources(*relationship)
@@ -235,9 +249,11 @@ module ActionDispatch
           related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore))
           options[:controller] ||= related_resource._type.to_s
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resources', via: [:get]
+          match formatted_relationship_name,
+                controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'get_related_resources', via: [:get],
+                as: relationship_name
         end
 
         protected

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-25 00:00:00.000000000 Z
+date: 2019-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler