jsonapi-resources 0.9.12 → 0.10.7

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: {}
     #           }
     #         }
     #       }
@@ -19,9 +17,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,79 +29,25 @@ 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)
-      current = @include_directives_hash
-      current_resource_klass = @resource_klass
-      current_path.split('.').each do |fragment|
-        fragment = fragment.to_sym
-
-        if current_resource_klass
-          current_relationship = current_resource_klass._relationships[fragment]
-          current_resource_klass = current_relationship.try(:resource_klass)
-        else
-          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 = 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
+    def parse_include(include)
+      path = JSONAPI::Path.new(resource_klass: @resource_klass,
+                               path_string: include,
+                               ensure_default_field: false,
+                               parse_fields: false)
 
-      ir.map do |name, sub_directive|
-        sub = get_includes(sub_directive, only_joined_includes)
-        sub.any? ? { name => sub } : name
-      end
-    end
+      current = @include_directives_hash
 
-    def parse_include(include)
-      parts = include.split('.')
-      local_path = ''
+      path.segments.each do |segment|
+        relationship_name = segment.relationship.name.to_sym
 
-      parts.each do |name|
-        local_path += local_path.length > 0 ? ".#{name}" : name
-        related = get_related(local_path)
-        related[:include] = true
+        current[:include_related][relationship_name] ||= { include_related: {} }
+        current = current[:include_related][relationship_name]
       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
+    rescue JSONAPI::Exceptions::InvalidRelationship => _e
+      raise JSONAPI::Exceptions::InvalidInclude.new(@resource_klass, include)
     end
   end
 end

data/lib/jsonapi/link_builder.rb

@@ -29,7 +29,7 @@ module JSONAPI
     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 }"
+        @primary_resources_url_cached ||= "#{ base_url }#{ engine_mount_point }#{ primary_resources_path }"
       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"
@@ -105,19 +105,16 @@ 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
-
-        unless scopes.empty?
-          "/#{ scopes.map {|scope| format_route(scope.to_s.underscore)}.compact.join('/') }/"
-        else
-          "/"
-        end
+      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('/') }/"
+      else
+        "/"
       end
     end
 
@@ -126,24 +123,20 @@ module JSONAPI
     end
 
     def resources_path(source_klass)
-      formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
+      @_resources_path ||= {}
+      @_resources_path[source_klass] ||= formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
     end
 
     def resource_path(source)
-      url = "#{resources_path(source.class)}"
-
-      unless source.class.singleton?
-        url = "#{url}/#{source.id}"
+      if source.class.singleton?
+        resources_path(source.class)
+      else
+        "#{resources_path(source.class)}/#{source.id}"
       end
-      url
     end
 
     def resource_url(source)
-      "#{ base_url }#{ serialized_engine_mount_point }#{ resource_path(source) }"
-    end
-
-    def serialized_engine_mount_point
-      engine_mount_point == "/" ? "" : engine_mount_point
+      "#{ base_url }#{ engine_mount_point }#{ 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
+    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_relationship_hash(parent_resource, relationship, resource_ids)
+      else
+        # :nocov:
+        {}
+        # :nocov:
+      end
+    end
   end
 end

data/lib/jsonapi/paginator.rb

@@ -13,9 +13,16 @@ module JSONAPI
       # :nocov:
     end
 
+    def requires_record_count
+      # :nocov:
+      self.class.requires_record_count
+      # :nocov:
+    end
+
     class << self
       def requires_record_count
         # :nocov:
+        # @deprecated
         false
         # :nocov:
       end
@@ -36,10 +43,15 @@ class OffsetPaginator < JSONAPI::Paginator
     verify_pagination_params
   end
 
+  # @deprecated
   def self.requires_record_count
     true
   end
 
+  def requires_record_count
+    true
+  end
+
   def apply(relation, _order_options)
     relation.offset(@offset).limit(@limit)
   end
@@ -127,10 +139,15 @@ class PagedPaginator < JSONAPI::Paginator
     verify_pagination_params
   end
 
+  # @deprecated
   def self.requires_record_count
     true
   end
 
+  def requires_record_count
+    true
+  end
+
   def calculate_page_count(record_count)
     (record_count / @size.to_f).ceil
   end

data/lib/jsonapi/path.rb

@@ -0,0 +1,43 @@
+module JSONAPI
+  class Path
+    attr_reader :segments, :resource_klass
+    def initialize(resource_klass:,
+                   path_string:,
+                   ensure_default_field: true,
+                   parse_fields: true)
+      @resource_klass = resource_klass
+
+      current_resource_klass = resource_klass
+      @segments = path_string.to_s.split('.').collect do |segment_string|
+        segment = PathSegment.parse(source_resource_klass: current_resource_klass,
+                                 segment_string: segment_string,
+                                 parse_fields: parse_fields)
+
+        current_resource_klass = segment.resource_klass
+        segment
+      end
+
+      if ensure_default_field && parse_fields && @segments.last.is_a?(PathSegment::Relationship)
+        last = @segments.last
+        @segments << PathSegment::Field.new(resource_klass: last.resource_klass,
+                                            field_name: last.resource_klass._primary_key)
+      end
+    end
+
+    def relationship_segments
+      @segments.select {|p| p.is_a?(PathSegment::Relationship)}
+    end
+
+    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

@@ -0,0 +1,76 @@
+module JSONAPI
+  class PathSegment
+    def self.parse(source_resource_klass:, segment_string:, parse_fields: true)
+      first_part, last_part = segment_string.split('#', 2)
+      relationship = source_resource_klass._relationship(first_part)
+
+      if relationship
+        if last_part
+          unless relationship.resource_types.include?(last_part)
+            raise JSONAPI::Exceptions::InvalidRelationship.new(source_resource_klass._type, segment_string)
+          end
+          resource_klass = source_resource_klass.resource_klass_for(last_part)
+        end
+        return PathSegment::Relationship.new(relationship: relationship, resource_klass: resource_klass)
+      else
+        if last_part.blank? && parse_fields
+          return PathSegment::Field.new(resource_klass: source_resource_klass, field_name: first_part)
+        else
+          raise JSONAPI::Exceptions::InvalidRelationship.new(source_resource_klass._type, segment_string)
+        end
+      end
+    end
+
+    class Relationship
+      attr_reader :relationship, :resource_klass
+
+      def initialize(relationship:, resource_klass: nil)
+        @relationship = relationship
+        @resource_klass = resource_klass
+      end
+
+      def eql?(other)
+        other.is_a?(JSONAPI::PathSegment::Relationship) && relationship == other.relationship && resource_klass == other.resource_klass
+      end
+
+      def hash
+        [relationship, resource_klass].hash
+      end
+
+      def to_s
+        @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
+      end
+
+      def path_specified_resource_klass?
+        !@resource_klass.nil?
+      end
+    end
+
+    class Field
+      attr_reader :resource_klass, :field_name
+
+      def initialize(resource_klass:, field_name:)
+        @resource_klass = resource_klass
+        @field_name = field_name
+      end
+
+      def eql?(other)
+        other.is_a?(JSONAPI::PathSegment::Field) && 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:
+        "#{resource_klass._type}.#{field_name.to_s}"
+        # :nocov:
+      end
+    end
+  end
+end