jsonapi-resources 0.9.12 → 0.10.0

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/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)
+        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)
+        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