jsonapi-resources 0.10.0.beta2 → 0.10.0

data/lib/jsonapi/cached_response_fragment.rb

@@ -1,22 +1,42 @@
 module JSONAPI
   class CachedResponseFragment
-    def self.fetch_cached_fragments(resource_klass, serializer_config_key, cache_ids, context)
-      context_json = resource_klass.attribute_caching_context(context).to_json
-      context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
-      context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
-
-      results = self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-
-      if JSONAPI.configuration.resource_cache_usage_report_function
-        miss_ids = results.select{|_k,v| v.nil? }.keys
-        JSONAPI.configuration.resource_cache_usage_report_function.call(
-            resource_klass.name,
-            cache_ids.size - miss_ids.size,
-            miss_ids.size
-        )
+
+    Lookup = Struct.new(:resource_klass, :serializer_config_key, :context, :context_key, :cache_ids) do
+
+      def type
+        resource_klass._type
       end
 
-      results
+      def keys
+        cache_ids.map do |(id, cache_key)|
+          [type, id, cache_key, serializer_config_key, context_key]
+        end
+      end
+    end
+
+    Write = Struct.new(:resource_klass, :resource, :serializer, :serializer_config_key, :context, :context_key, :relationship_data) do
+      def to_key_value
+
+        (id, cache_key) = resource.cache_id
+
+        json = serializer.object_hash(resource, relationship_data)
+
+        cr = CachedResponseFragment.new(
+          resource_klass,
+          id,
+          json['type'],
+          context,
+          resource.fetchable_fields,
+          json['relationships'],
+          json['links'],
+          json['attributes'],
+          json['meta']
+        )
+
+        key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
+
+        [key, cr]
+      end
     end
 
     attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
@@ -50,26 +70,46 @@ module JSONAPI
       }
     end
 
-    private
+    # @param [Lookup[]] lookups
+    # @return [Hash<Class<Resource>, Hash<ID, CachedResourceFragment>>]
+    def self.lookup(lookups, context)
+      type_to_klass = lookups.map {|l| [l.type, l.resource_klass]}.to_h
 
-    def self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-      type = resource_klass._type
+      keys = lookups.map(&:keys).flatten(1)
 
-      keys = cache_ids.map do |(id, cache_key)|
-        [type, id, cache_key, serializer_config_key, context_key]
-      end
+      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject {|_, v| v.nil?}
+
+      return keys.inject({}) do |hash, key|
+        (type, id, _, _) = key
+        resource_klass = type_to_klass[type]
+        hash[resource_klass] ||= {}
 
-      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject{|_,v| v.nil? }
-      return keys.each_with_object({}) do |key, hash|
-        (_, id, _, _) = key
         if hits.has_key?(key)
-          hash[id] = self.from_cache_value(resource_klass, context, hits[key])
+          hash[resource_klass][id] = self.from_cache_value(resource_klass, context, hits[key])
         else
-          hash[id] = nil
+          hash[resource_klass][id] = nil
         end
+
+        hash
       end
     end
 
+    # @param [Write[]] lookups
+    def self.write(writes)
+      key_values = writes.map(&:to_key_value)
+
+      to_write = key_values.map {|(k, v)| [k, v.to_cache_value]}.to_h
+
+      if JSONAPI.configuration.resource_cache.respond_to? :write_multi
+        JSONAPI.configuration.resource_cache.write_multi(to_write)
+      else
+        to_write.each do |key, value|
+          JSONAPI.configuration.resource_cache.write(key, value)
+        end
+      end
+
+    end
+
     def self.from_cache_value(resource_klass, context, h)
       new(
         resource_klass,
@@ -83,28 +123,5 @@ module JSONAPI
         h.fetch(:meta, nil)
       )
     end
-
-    def self.write(resource_klass, resource, serializer, serializer_config_key, context, context_key, relationship_data )
-      (id, cache_key) = resource.cache_id
-
-      json = serializer.object_hash(resource, relationship_data)
-
-      cr = self.new(
-        resource_klass,
-        id,
-        json['type'],
-        context,
-        resource.fetchable_fields,
-        json['relationships'],
-        json['links'],
-        json['attributes'],
-        json['meta']
-      )
-
-      key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
-      JSONAPI.configuration.resource_cache.write(key, cr.to_cache_value)
-      return [id, cr]
-    end
-
   end
 end

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,8 @@ module JSONAPI
                 :route_format,
                 :raise_if_parameters_not_allowed,
                 :warn_on_route_setup_issues,
+                :warn_on_missing_routes,
+                :warn_on_performance_issues,
                 :default_allow_include_to_one,
                 :default_allow_include_to_many,
                 :allow_sort,
@@ -17,7 +18,6 @@ module JSONAPI
                 :default_paginator,
                 :default_page_size,
                 :maximum_page_size,
-                :resource_finder,
                 :default_processor_klass,
                 :use_text_errors,
                 :top_level_links_include_pagination,
@@ -38,7 +38,8 @@ module JSONAPI
                 :default_caching,
                 :default_resource_cache_field,
                 :resource_cache_digest_function,
-                :resource_cache_usage_report_function
+                :resource_cache_usage_report_function,
+                :default_exclude_links
 
     def initialize
       #:underscored_key, :camelized_key, :dasherized_key, or custom
@@ -59,6 +60,8 @@ module JSONAPI
       self.raise_if_parameters_not_allowed = true
 
       self.warn_on_route_setup_issues = true
+      self.warn_on_missing_routes = true
+      self.warn_on_performance_issues = true
 
       # :none, :offset, :paged, or a custom paginator name
       self.default_paginator = :none
@@ -105,12 +108,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
@@ -155,6 +152,12 @@ module JSONAPI
       # Optionally provide a callable which JSONAPI will call with information about cache
       # performance. Should accept three arguments: resource name, hits count, misses count.
       self.resource_cache_usage_report_function = nil
+
+      # Global configuration for links exclusion
+      # Controls whether to generate links like `self`, `related` with all the resources
+      # and relationships. Accepts either `:default`, `:none`, or array containing the
+      # specific default links to exclude, which may be `:self` and `:related`.
+      self.default_exclude_links = :none
     end
 
     def cache_formatters=(bool)
@@ -225,10 +228,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 +272,10 @@ module JSONAPI
 
     attr_writer :warn_on_route_setup_issues
 
+    attr_writer :warn_on_missing_routes
+
+    attr_writer :warn_on_performance_issues
+
     attr_writer :use_relationship_reflection
 
     attr_writer :resource_cache
@@ -284,6 +287,8 @@ module JSONAPI
     attr_writer :resource_cache_digest_function
 
     attr_writer :resource_cache_usage_report_function
+
+    attr_writer :default_exclude_links
   end
 
   class << self

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

@@ -3,109 +3,100 @@ module JSONAPI
     attr_reader :base_url,
                 :primary_resource_klass,
                 :route_formatter,
-                :engine_name
+                :engine,
+                :engine_mount_point,
+                :url_helpers
+
+    @@url_helper_methods = {}
 
     def initialize(config = {})
-      @base_url               = config[:base_url]
+      @base_url = config[:base_url]
       @primary_resource_klass = config[:primary_resource_klass]
-      @route_formatter        = config[:route_formatter]
-      @engine_name            = build_engine_name
+      @route_formatter = config[:route_formatter]
+      @engine = build_engine
+      @engine_mount_point = @engine ? @engine.routes.find_script_name({}) : ""
 
-      # 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)
-      end
+      # url_helpers may be either a controller which has the route helper methods, or the application router's
+      # url helpers module, `Rails.application.routes.url_helpers`. Because the method no longer behaves as a
+      # singleton, and it's expensive to generate the module, the controller is preferred.
+      @url_helpers = config[:url_helpers]
     end
 
     def engine?
-      !!@engine_name
+      !!@engine
     end
 
     def primary_resources_url
-      if engine?
-        engine_primary_resources_url
+      if @primary_resource_klass._routed
+        primary_resources_path = resources_path(primary_resource_klass)
+        @primary_resources_url_cached ||= "#{ base_url }#{ engine_mount_point }#{ primary_resources_path }"
       else
-        regular_primary_resources_url
+        if JSONAPI.configuration.warn_on_missing_routes && !@primary_resource_klass._warned_missing_route
+          warn "primary_resources_url for #{@primary_resource_klass} could not be generated"
+          @primary_resource_klass._warned_missing_route = true
+        end
+        nil
       end
     end
 
     def query_link(query_params)
-      "#{ primary_resources_url }?#{ query_params.to_query }"
+      url = primary_resources_url
+      return url if url.nil?
+      "#{ url }?#{ query_params.to_query }"
     end
 
     def relationships_related_link(source, relationship, query_params = {})
-      url = "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
-      url = "#{ url }?#{ query_params.to_query }" if query_params.present?
-      url
+      if relationship._routed
+        url = "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
+        url = "#{ url }?#{ query_params.to_query }" if query_params.present?
+        url
+      else
+        if JSONAPI.configuration.warn_on_missing_routes && !relationship._warned_missing_route
+          warn "related_link for #{relationship} could not be generated"
+          relationship._warned_missing_route = true
+        end
+        nil
+      end
     end
 
     def relationships_self_link(source, relationship)
-      "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+      if relationship._routed
+        "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+      else
+        if JSONAPI.configuration.warn_on_missing_routes && !relationship._warned_missing_route
+          warn "self_link for #{relationship} could not be generated"
+          relationship._warned_missing_route = true
+        end
+        nil
+      end
     end
 
     def self_link(source)
-      if engine?
-        engine_resource_url(source)
+      if source.class._routed
+        resource_url(source)
       else
-        regular_resource_url(source)
+        if JSONAPI.configuration.warn_on_missing_routes && !source.class._warned_missing_route
+          warn "self_link for #{source.class} could not be generated"
+          source.class._warned_missing_route = true
+        end
+        nil
       end
     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
-      # :nocov:
+
+          # :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)
-    end
-
-    def engine_primary_resources_path
-      engine_path_from_resource_class(primary_resource_klass)
-    end
-
-    def engine_primary_resources_url
-      "#{ base_url }#{ engine_primary_resources_path }"
-    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)
-    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("_")
-    end
-
-    def engine_resource_url(source)
-      "#{ base_url }#{ engine_resource_path(source) }"
-    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"
+        # :nocov:
       end
     end
 
@@ -114,10 +105,14 @@ module JSONAPI
     end
 
     def formatted_module_path_from_class(klass)
-      scopes = module_scopes_from_class(klass)
+      scopes = if @engine
+                 module_scopes_from_class(klass)[1..-1]
+               else
+                 module_scopes_from_class(klass)
+               end
 
       unless scopes.empty?
-        "/#{ scopes.map{ |scope| format_route(scope.to_s.underscore) }.compact.join('/') }/"
+        "/#{ scopes.map {|scope| format_route(scope.to_s.underscore)}.compact.join('/') }/"
       else
         "/"
       end
@@ -127,30 +122,21 @@ module JSONAPI
       klass.name.to_s.split("::")[0...-1]
     end
 
-    def regular_resources_path(source_klass)
-      @resources_path_cache.get(source_klass)
-    end
-
-    def regular_primary_resources_path
-      regular_resources_path(primary_resource_klass)
+    def resources_path(source_klass)
+      @_resources_path ||= {}
+      @_resources_path[source_klass] ||= formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
     end
 
-    def regular_primary_resources_url
-      "#{ base_url }#{ regular_primary_resources_path }"
-    end
-
-    def regular_resource_path(source)
-      if source.is_a?(JSONAPI::CachedResponseFragment)
-        # :nocov:
-        "#{regular_resources_path(source.resource_klass)}/#{source.id}"
-        # :nocov:
+    def resource_path(source)
+      if source.class.singleton?
+        resources_path(source.class)
       else
-        "#{regular_resources_path(source.class)}/#{source.id}"
+        "#{resources_path(source.class)}/#{source.id}"
       end
     end
 
-    def regular_resource_url(source)
-      "#{ base_url }#{ regular_resource_path(source) }"
+    def resource_url(source)
+      "#{ base_url }#{ engine_mount_point }#{ resource_path(source) }"
     end
 
     def route_for_relationship(relationship)

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/path.rb

@@ -31,5 +31,13 @@ module JSONAPI
     def relationship_path_string
       relationship_segments.collect(&:to_s).join('.')
     end
+
+    def last_relationship
+      if @segments.last.is_a?(PathSegment::Relationship)
+        @segments.last
+      else
+        @segments[-2]
+      end
+    end
   end
 end

data/lib/jsonapi/path_segment.rb

@@ -22,19 +22,27 @@ module JSONAPI
     end
 
     class Relationship
-      attr_reader :relationship
+      attr_reader :relationship, :resource_klass
 
-      def initialize(relationship:, resource_klass:)
+      def initialize(relationship:, resource_klass: nil)
         @relationship = relationship
         @resource_klass = resource_klass
       end
 
+      def eql?(other)
+        relationship == other.relationship && resource_klass == other.resource_klass
+      end
+
+      def hash
+        [relationship, resource_klass].hash
+      end
+
       def to_s
-        @resource_klass ? "#{relationship.name}##{resource_klass._type}" : "#{relationship.name}"
+        @resource_klass ? "#{relationship.parent_resource_klass._type}.#{relationship.name}##{resource_klass._type}" : "#{resource_klass._type}.#{relationship.name}"
       end
 
       def resource_klass
-        @resource_klass || @relationship.resource_klass
+        @resource_klass || relationship.resource_klass
       end
 
       def path_specified_resource_klass?
@@ -50,13 +58,17 @@ module JSONAPI
         @field_name = field_name
       end
 
+      def eql?(other)
+        field_name == other.field_name && resource_klass == other.resource_klass
+      end
+
       def delegated_field_name
         resource_klass._attribute_delegated_name(field_name)
       end
 
       def to_s
         # :nocov:
-        field_name.to_s
+        "#{resource_klass._type}.#{field_name.to_s}"
         # :nocov:
       end
     end

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

@@ -7,6 +7,8 @@ module JSONAPI
 
     attr_writer :allow_include
 
+    attr_accessor :_routed, :_warned_missing_route
+
     def initialize(name, options = {})
       @name = name.to_s
       @options = options
@@ -27,11 +29,17 @@ module JSONAPI
       @class_name = nil
       @inverse_relationship = nil
 
-      # Custom methods are reserved for use in resource finders. Not used in the default ActiveRelationResourceFinder
+      @_routed = false
+      @_warned_missing_route = false
+
+      exclude_links(options.fetch(:exclude_links, JSONAPI.configuration.default_exclude_links))
+
+      # Custom methods are reserved for future use
       @custom_methods = options.fetch(:custom_methods, {})
     end
 
     alias_method :polymorphic?, :polymorphic
+    alias_method :parent_resource_klass, :parent_resource
 
     def primary_key
       # :nocov:
@@ -98,6 +106,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
 
@@ -113,7 +142,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
 
@@ -163,7 +192,7 @@ module JSONAPI
 
       def to_s
         # :nocov: useful for debugging
-        "#{parent_resource._type}.#{name} => (ToMany) #{resource_klass._type}"
+        "#{parent_resource}.#{name}(ToMany)"
         # :nocov:
       end