sanger-jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/operation_result.rb

@@ -1,15 +1,23 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class OperationResult
     attr_accessor :code
     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 +28,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 LinksObjectOperationResult < OperationResult
-    attr_accessor :parent_resource, :relationship
+  class RelationshipOperationResult < 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_relationship_hash(parent_resource, relationship, resource_ids)
+      else
+        # :nocov:
+        {}
+        # :nocov:
+      end
+    end
   end
 end

data/lib/jsonapi/paginator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Paginator
     def initialize(_params)

data/lib/jsonapi/path.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+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,78 @@
+# frozen_string_literal: true
+
+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?(self.class) && 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?(self.class) && 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