jsonapi-resources 0.9.12 → 0.10.0.beta1

data/lib/jsonapi/formatter.rb

@@ -108,7 +108,7 @@ end
 
 class DasherizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
-    def format(key)
+    def format(_key)
       super.underscore.dasherize
     end
 
@@ -146,7 +146,7 @@ end
 
 class CamelizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    def format(route)
+    def format(_route)
       super.camelize(:lower)
     end
 
@@ -158,7 +158,7 @@ end
 
 class DasherizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    def format(route)
+    def format(_route)
       super.dasherize
     end
 

data/lib/jsonapi/include_directives.rb

@@ -19,9 +19,8 @@ module JSONAPI
     #   }
     # }
 
-    def initialize(resource_klass, includes_array, force_eager_load: false)
+    def initialize(resource_klass, includes_array)
       @resource_klass = resource_klass
-      @force_eager_load = force_eager_load
       @include_directives_hash = { include_related: {} }
       includes_array.each do |include|
         parse_include(include)
@@ -32,24 +31,6 @@ module JSONAPI
       @include_directives_hash
     end
 
-    def model_includes
-      get_includes(@include_directives_hash)
-    end
-
-    def paths
-      delve_paths(get_includes(@include_directives_hash, false))
-    end
-
-    def merge_filter(relation, filter)
-      config = include_config(relation.to_sym)
-      config[:include_filters] ||= {}
-      config[:include_filters].merge!(filter)
-    end
-
-    def include_config(relation)
-      @include_directives_hash[:include_related][relation]
-    end
-
     private
 
     def get_related(current_path)
@@ -65,24 +46,13 @@ module JSONAPI
           raise JSONAPI::Exceptions::InvalidInclude.new(current_resource_klass, current_path)
         end
 
-        include_in_join = @force_eager_load || !current_relationship || current_relationship.eager_load_on_include
 
-        current[:include_related][fragment] ||= { include: false, include_related: {}, include_in_join: include_in_join }
+        current[:include_related][fragment] ||= { include: false, include_related: {} }
         current = current[:include_related][fragment]
       end
       current
     end
 
-    def get_includes(directive, only_joined_includes = true)
-      ir = directive[:include_related]
-      ir = ir.select { |k,v| v[:include_in_join] } if only_joined_includes
-
-      ir.map do |name, sub_directive|
-        sub = get_includes(sub_directive, only_joined_includes)
-        sub.any? ? { name => sub } : name
-      end
-    end
-
     def parse_include(include)
       parts = include.split('.')
       local_path = ''
@@ -93,18 +63,5 @@ module JSONAPI
         related[:include] = true
       end
     end
-
-    def delve_paths(obj)
-      case obj
-        when Array
-          obj.map{|elem| delve_paths(elem)}.flatten(1)
-        when Hash
-          obj.map{|k,v| [[k]] + delve_paths(v).map{|path| [k] + path } }.flatten(1)
-        when Symbol, String
-          [[obj]]
-        else
-          raise "delve_paths cannot descend into #{obj.class.name}"
-      end
-    end
   end
 end

data/lib/jsonapi/link_builder.rb

@@ -3,100 +3,109 @@ module JSONAPI
     attr_reader :base_url,
                 :primary_resource_klass,
                 :route_formatter,
-                :engine,
-                :engine_mount_point,
-                :url_helpers
-
-    @@url_helper_methods = {}
+                :engine_name
 
     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 = build_engine
-      @engine_mount_point = @engine ? @engine.routes.find_script_name({}) : ""
+      @route_formatter        = config[:route_formatter]
+      @engine_name            = build_engine_name
 
-      # 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]
+      # 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
     end
 
     def engine?
-      !!@engine
+      !!@engine_name
     end
 
     def primary_resources_url
-      if @primary_resource_klass._routed
-        primary_resources_path = resources_path(primary_resource_klass)
-        @primary_resources_url_cached ||= "#{ base_url }#{ serialized_engine_mount_point }#{ primary_resources_path }"
+      if engine?
+        engine_primary_resources_url
       else
-        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
+        regular_primary_resources_url
       end
     end
 
     def query_link(query_params)
-      url = primary_resources_url
-      return url if url.nil?
-      "#{ url }?#{ query_params.to_query }"
+      "#{ primary_resources_url }?#{ query_params.to_query }"
     end
 
     def relationships_related_link(source, relationship, query_params = {})
-      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
+      url = "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
+      url = "#{ url }?#{ query_params.to_query }" if query_params.present?
+      url
     end
 
     def relationships_self_link(source, 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
+      "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
     end
 
     def self_link(source)
-      if source.class._routed
-        resource_url(source)
+      if engine?
+        engine_resource_url(source)
       else
-        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
+        regular_resource_url(source)
       end
     end
 
     private
 
-    def build_engine
+    def build_engine_name
       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:
+      # :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"
       end
     end
 
@@ -105,19 +114,12 @@ module JSONAPI
     end
 
     def formatted_module_path_from_class(klass)
-      @_module_path_cache ||= {}
-      @_module_path_cache[klass] ||= begin
-        scopes = if @engine
-                   module_scopes_from_class(klass)[1..-1]
-                 else
-                   module_scopes_from_class(klass)
-                 end
+      scopes = module_scopes_from_class(klass)
 
-        unless scopes.empty?
-          "/#{ scopes.map {|scope| format_route(scope.to_s.underscore)}.compact.join('/') }/"
-        else
-          "/"
-        end
+      unless scopes.empty?
+        "/#{ scopes.map{ |scope| format_route(scope.to_s.underscore) }.compact.join('/') }/"
+      else
+        "/"
       end
     end
 
@@ -125,25 +127,30 @@ module JSONAPI
       klass.name.to_s.split("::")[0...-1]
     end
 
-    def resources_path(source_klass)
-      formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
+    def regular_resources_path(source_klass)
+      @resources_path_cache.get(source_klass)
     end
 
-    def resource_path(source)
-      url = "#{resources_path(source.class)}"
+    def regular_primary_resources_path
+      regular_resources_path(primary_resource_klass)
+    end
 
-      unless source.class.singleton?
-        url = "#{url}/#{source.id}"
-      end
-      url
+    def regular_primary_resources_url
+      "#{ base_url }#{ regular_primary_resources_path }"
     end
 
-    def resource_url(source)
-      "#{ base_url }#{ serialized_engine_mount_point }#{ resource_path(source) }"
+    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
     end
 
-    def serialized_engine_mount_point
-      engine_mount_point == "/" ? "" : engine_mount_point
+    def regular_resource_url(source)
+      "#{ base_url }#{ regular_resource_path(source) }"
     end
 
     def route_for_relationship(relationship)

data/lib/jsonapi/operation.rb

@@ -8,17 +8,28 @@ module JSONAPI
       @options = options
     end
 
-    def transactional?
-      JSONAPI::Processor._processor_from_resource_type(resource_klass).transactional_operation_type?(operation_type)
-    end
-
     def process
       processor.process
     end
 
     private
     def processor
-      JSONAPI::Processor.processor_instance_for(resource_klass, operation_type, options)
+      self.class.processor_instance_for(resource_klass, operation_type, options)
+    end
+
+    class << self
+      def processor_instance_for(resource_klass, operation_type, params)
+        _processor_from_resource_type(resource_klass).new(resource_klass, operation_type, params)
+      end
+
+      def _processor_from_resource_type(resource_klass)
+        processor = resource_klass.name.gsub(/Resource$/,'Processor').safe_constantize
+        if processor.nil?
+          processor = JSONAPI.configuration.default_processor_klass
+        end
+
+        return processor
+      end
     end
   end
 end

data/lib/jsonapi/operation_result.rb

@@ -4,12 +4,18 @@ module JSONAPI
     attr_accessor :meta
     attr_accessor :links
     attr_accessor :options
+    attr_accessor :warnings
 
     def initialize(code, options = {})
-      @code = code
+      @code = Rack::Utils.status_code(code)
       @options = options
       @meta = options.fetch(:meta, {})
       @links = options.fetch(:links, {})
+      @warnings = options.fetch(:warnings, {})
+    end
+
+    def to_hash(serializer = nil)
+      {}
     end
   end
 
@@ -20,46 +26,98 @@ module JSONAPI
       @errors = errors
       super(code, options)
     end
+
+    def to_hash(serializer = nil)
+      {
+          errors: errors.collect do |error|
+            # :nocov:
+            error.to_hash
+            # :nocov:
+          end
+      }
+    end
   end
 
-  class ResourceOperationResult < OperationResult
-    attr_accessor :resource
+  class ResourceSetOperationResult < OperationResult
+    attr_accessor :resource_set, :pagination_params
 
-    def initialize(code, resource, options = {})
-      @resource = resource
+    def initialize(code, resource_set, options = {})
+      @resource_set = resource_set
+      @pagination_params = options.fetch(:pagination_params, {})
       super(code, options)
     end
+
+    def to_hash(serializer)
+      if serializer
+        serializer.serialize_resource_set_to_hash_single(resource_set)
+      else
+        # :nocov:
+        {}
+        # :nocov:
+      end
+    end
   end
 
-  class ResourcesOperationResult < OperationResult
-    attr_accessor :resources, :pagination_params, :record_count, :page_count
+  class ResourcesSetOperationResult < OperationResult
+    attr_accessor :resource_set, :pagination_params, :record_count, :page_count
 
-    def initialize(code, resources, options = {})
-      @resources = resources
+    def initialize(code, resource_set, options = {})
+      @resource_set = resource_set
       @pagination_params = options.fetch(:pagination_params, {})
       @record_count = options[:record_count]
       @page_count = options[:page_count]
       super(code, options)
     end
+
+    def to_hash(serializer)
+      if serializer
+        serializer.serialize_resource_set_to_hash_plural(resource_set)
+      else
+        # :nocov:
+        {}
+        # :nocov:
+      end
+    end
   end
 
-  class RelatedResourcesOperationResult < ResourcesOperationResult
-    attr_accessor :source_resource, :_type
+  class RelatedResourcesSetOperationResult < ResourcesSetOperationResult
+    attr_accessor :resource_set, :source_resource, :_type
 
-    def initialize(code, source_resource, type, resources, options = {})
+    def initialize(code, source_resource, type, resource_set, options = {})
       @source_resource = source_resource
       @_type = type
-      super(code, resources, options)
+      super(code, resource_set, options)
+    end
+
+    def to_hash(serializer = nil)
+      if serializer
+        serializer.serialize_related_resource_set_to_hash_plural(resource_set, source_resource)
+      else
+        # :nocov:
+        {}
+        # :nocov:
+      end
     end
   end
 
-  class RelationshipOperationResult < OperationResult
-    attr_accessor :parent_resource, :relationship
+  class LinksObjectOperationResult < OperationResult
+    attr_accessor :parent_resource, :relationship, :resource_ids
 
-    def initialize(code, parent_resource, relationship, options = {})
+    def initialize(code, parent_resource, relationship, resource_ids, options = {})
       @parent_resource = parent_resource
       @relationship = relationship
+      @resource_ids = resource_ids
       super(code, options)
     end
+
+    def to_hash(serializer = nil)
+      if serializer
+        serializer.serialize_to_links_hash(parent_resource, relationship, resource_ids)
+      else
+        # :nocov:
+        {}
+        # :nocov:
+      end
+    end
   end
 end