jsonapi-resources 0.9.0 → 0.10.6

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,69 +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
-
     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
-          warn "[RELATIONSHIP NOT FOUND] Relationship could not be found for #{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

@@ -3,107 +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
-      rescue LoadError => e
-        nil
-      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:
+      rescue LoadError => _e
+        nil
+        # :nocov:
       end
     end
 
@@ -112,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) }.join('/') }/"
+        "/#{ scopes.map {|scope| format_route(scope.to_s.underscore)}.compact.join('/') }/"
       else
         "/"
       end
@@ -125,24 +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)
-      "#{regular_resources_path(source.class)}/#{source.id}"
+    def resource_path(source)
+      if source.class.singleton?
+        resources_path(source.class)
+      else
+        "#{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.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 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/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