jsonapi-resources 0.9.0.beta1 → 0.9.0.beta2

data/lib/jsonapi/link_builder.rb

@@ -57,8 +57,12 @@ module JSONAPI
     def build_engine_name
       scopes = module_scopes_from_class(primary_resource_klass)
 
-      unless scopes.empty?
-        "#{ scopes.first.to_s.camelize }::Engine".safe_constantize
+      begin
+        unless scopes.empty?
+          "#{ scopes.first.to_s.camelize }::Engine".safe_constantize
+        end
+      rescue LoadError => e
+        nil
       end
     end
 

data/lib/jsonapi/mime_types.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module JSONAPI
   MEDIA_TYPE = 'application/vnd.api+json'
 
@@ -19,9 +21,18 @@ module JSONAPI
 
     def self.parser
       lambda do |body|
-        data = JSON.parse(body)
-        data = {:_json => data} unless data.is_a?(Hash)
-        data.with_indifferent_access
+        begin
+          data = JSON.parse(body)
+          if data.is_a?(Hash)
+            data.with_indifferent_access
+          else
+            fail JSONAPI::Exceptions::InvalidRequestFormat.new
+          end
+        rescue JSON::ParserError => e
+          { _parser_exception: JSONAPI::Exceptions::BadRequest.new(e.to_s)  }
+        rescue => e
+          { _parser_exception: e }
+        end
       end
     end
   end

data/lib/jsonapi/paginator.rb

@@ -110,7 +110,7 @@ class OffsetPaginator < JSONAPI::Paginator
       fail JSONAPI::Exceptions::InvalidPageValue.new(:limit, @limit)
     elsif @limit > JSONAPI.configuration.maximum_page_size
       fail JSONAPI::Exceptions::InvalidPageValue.new(:limit, @limit,
-                                                     "Limit exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
+                                                     detail: "Limit exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
     end
 
     if @offset < 0
@@ -199,7 +199,7 @@ class PagedPaginator < JSONAPI::Paginator
       fail JSONAPI::Exceptions::InvalidPageValue.new(:size, @size)
     elsif @size > JSONAPI.configuration.maximum_page_size
       fail JSONAPI::Exceptions::InvalidPageValue.new(:size, @size,
-                                                     "size exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
+                                                     detail: "size exceeds maximum page size of #{JSONAPI.configuration.maximum_page_size}.")
     end
 
     if @number < 1

data/lib/jsonapi/relationship_builder.rb

@@ -120,10 +120,16 @@ module JSONAPI
       define_on_resource relationship_name do |options = {}|
         relationship = self.class._relationships[relationship_name]
 
-        resource_klass = relationship.resource_klass
-        if resource_klass
+        if relationship.polymorphic?
           associated_model = public_send(associated_records_method_name)
-          return associated_model ? resource_klass.new(associated_model, @context) : nil
+          resource_klass = self.class.resource_for_model(associated_model) if associated_model
+          return resource_klass.new(associated_model, @context) if resource_klass && associated_model
+        else
+          resource_klass = relationship.resource_klass
+          if resource_klass
+            associated_model = public_send(associated_records_method_name)
+            return associated_model ? resource_klass.new(associated_model, @context) : nil
+          end
         end
       end
     end

data/lib/jsonapi/request_parser.rb

@@ -34,6 +34,7 @@ module JSONAPI
 
       setup_action_method_name = "setup_#{params[:action]}_action"
       if respond_to?(setup_action_method_name)
+        raise params[:_parser_exception] if params[:_parser_exception]
         send(setup_action_method_name, params)
       end
     rescue ActionController::ParameterMissing => e
@@ -201,7 +202,7 @@ module JSONAPI
       relationship = resource_klass._relationship(relationship_name)
       if relationship && format_key(relationship_name) == include_parts.first
         unless include_parts.last.empty?
-          check_include(Resource.resource_for(@resource_klass.module_path + relationship.class_name.to_s.underscore), include_parts.last.partition('.'))
+          check_include(Resource.resource_for(resource_klass.module_path + relationship.class_name.to_s.underscore), include_parts.last.partition('.'))
         end
       else
         @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
@@ -209,23 +210,28 @@ module JSONAPI
       end
     end
 
-    def parse_include_directives(include)
-      return if include.nil?
+    def parse_include_directives(raw_include)
+      return unless raw_include
 
       unless JSONAPI.configuration.allow_include
         fail JSONAPI::Exceptions::ParametersNotAllowed.new([:include])
       end
 
-      included_resources = CSV.parse_line(include)
-      return if included_resources.nil?
+      included_resources = []
+      begin
+        included_resources += CSV.parse_line(raw_include)
+      rescue CSV::MalformedCSVError
+        fail JSONAPI::Exceptions::InvalidInclude.new(format_key(@resource_klass._type), raw_include)
+      end
+
+      return if included_resources.empty?
 
-      include = []
-      included_resources.each do |included_resource|
+      result = included_resources.map do |included_resource|
         check_include(@resource_klass, included_resource.partition('.'))
-        include.push(unformat_key(included_resource).to_s)
+        unformat_key(included_resource).to_s
       end
 
-      @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, include)
+      @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, result)
     end
 
     def parse_filters(filters)
@@ -264,7 +270,15 @@ module JSONAPI
         fail JSONAPI::Exceptions::ParametersNotAllowed.new([:sort])
       end
 
-      @sort_criteria = CSV.parse_line(URI.unescape(sort_criteria)).collect do |sort|
+      sorts = []
+      begin
+        raw = URI.unescape(sort_criteria)
+        sorts += CSV.parse_line(raw)
+      rescue CSV::MalformedCSVError
+        fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(@resource_klass._type), raw)
+      end
+
+      @sort_criteria = sorts.collect do |sort|
         if sort.start_with?('-')
           sort_criteria = { field: unformat_key(sort[1..-1]).to_s }
           sort_criteria[:direction] = :desc

data/lib/jsonapi/resource.rb

@@ -416,18 +416,15 @@ module JSONAPI
         subclass.immutable(false)
         subclass.caching(false)
         subclass._attributes = (_attributes || {}).dup
+
         subclass._model_hints = (_model_hints || {}).dup
 
-        subclass._relationships = {}
-        # Add the relationships from the base class to the subclass using the original options
-        if _relationships.is_a?(Hash)
-          _relationships.each_value do |relationship|
-            options = relationship.options.dup
-            options[:parent_resource] = subclass
-            subclass._add_relationship(relationship.class, relationship.name, options)
-          end
+        unless _model_name.empty?
+          subclass.model_name(_model_name, add_model_hint: (_model_hints && !_model_hints[_model_name].nil?) == true)
         end
 
+        subclass.rebuild_relationships(_relationships || {})
+
         subclass._allowed_filters = (_allowed_filters || Set.new).dup
 
         type = subclass.name.demodulize.sub(/Resource$/, '').underscore
@@ -438,6 +435,20 @@ module JSONAPI
         check_reserved_resource_name(subclass._type, subclass.name)
       end
 
+      def rebuild_relationships(relationships)
+        original_relationships = relationships.deep_dup
+
+        @_relationships = {}
+
+        if original_relationships.is_a?(Hash)
+          original_relationships.each_value do |relationship|
+            options = relationship.options.dup
+            options[:parent_resource] = self
+            _add_relationship(relationship.class, relationship.name, options)
+          end
+        end
+      end
+
       def resource_for(type)
         type = type.underscore
         type_with_module = type.include?('/') ? type : module_path + type
@@ -554,6 +565,8 @@ module JSONAPI
         @_model_name = model.to_sym
 
         model_hint(model: @_model_name, resource: self) unless options[:add_model_hint] == false
+
+        rebuild_relationships(_relationships)
       end
 
       def model_hint(model: _model_name, resource: _type)
@@ -807,7 +820,11 @@ module JSONAPI
       def verify_filter(filter, raw, context = nil)
         filter_values = []
         if raw.present?
-          filter_values += raw.is_a?(String) ? CSV.parse_line(raw) : [raw]
+          begin
+            filter_values += raw.is_a?(String) ? CSV.parse_line(raw) : [raw]
+          rescue CSV::MalformedCSVError
+            filter_values << raw
+          end
         end
 
         strategy = _allowed_filters.fetch(filter, Hash.new)[:verify]
@@ -900,10 +917,11 @@ module JSONAPI
         if _abstract
           return ''
         else
-          return @_model_name if defined?(@_model_name)
+          return @_model_name.to_s if defined?(@_model_name)
           class_name = self.name
           return '' if class_name.nil?
-          return @_model_name = class_name.demodulize.sub(/Resource$/, '')
+          @_model_name = class_name.demodulize.sub(/Resource$/, '')
+          return @_model_name.to_s
         end
       end
 
@@ -974,11 +992,17 @@ module JSONAPI
       def _model_class
         return nil if _abstract
 
-        return @model if defined?(@model)
-        return nil if self.name.to_s.blank? && _model_name.to_s.blank?
-        @model = _model_name.to_s.safe_constantize
-        warn "[MODEL NOT FOUND] Model could not be found for #{self.name}. If this a base Resource declare it as abstract." if @model.nil?
-        @model
+        return @model_class if @model_class
+
+        model_name = _model_name
+        return nil if model_name.to_s.blank?
+
+        @model_class = model_name.to_s.safe_constantize
+        if @model_class.nil?
+          warn "[MODEL NOT FOUND] Model could not be found for #{self.name}. If this a base Resource declare it as abstract."
+        end
+
+        @model_class
       end
 
       def _allowed_filter?(filter)
@@ -1040,7 +1064,7 @@ module JSONAPI
           cache_ids = pluck_arel_attributes(records, t[_primary_key], t[_cache_field])
           resources = CachedResourceFragment.fetch_fragments(self, serializer, options[:context], cache_ids)
         else
-          resources = resources_for(records, options).map{|r| [r.id, r] }.to_h
+          resources = resources_for(records, options[:context]).map{|r| [r.id, r] }.to_h
         end
 
         preload_included_fragments(resources, records, serializer, options)
@@ -1102,7 +1126,6 @@ module JSONAPI
         include_directives = options[:include_directives]
         return unless include_directives
 
-        relevant_options = options.except(:include_directives, :order, :paginator)
         context = options[:context]
 
         # For each association, including indirect associations, find the target record ids.
@@ -1133,8 +1156,15 @@ module JSONAPI
 
           # For each step on the path, figure out what the actual table name/alias in the join
           # will be, and include the primary key of that table in our list of fields to select
+          non_polymorphic = true
           path.each do |elem|
             relationship = klass._relationships[elem]
+            if relationship.polymorphic
+              # Can't preload through a polymorphic belongs_to association, ResourceSerializer
+              # will just have to bypass the cache and load the real Resource.
+              non_polymorphic = false
+              break
+            end
             assocs_path << relationship.relation_name(options).to_sym
             # Converts [:a, :b, :c] to Rails-style { :a => { :b => :c }}
             ar_hash = assocs_path.reverse.reduce{|memo, step| { step => memo } }
@@ -1148,6 +1178,7 @@ module JSONAPI
             klass = relationship.resource_klass
             pluck_attrs << table[klass._primary_key]
           end
+          next unless non_polymorphic
 
           # Pre-fill empty hashes for each resource up to the end of the path.
           # This allows us to later distinguish between a preload that returned nothing
@@ -1188,7 +1219,7 @@ module JSONAPI
               .map(&:last)
               .reject{|id| target_resources[klass.name].has_key?(id) }
               .uniq
-            found = klass.find({klass._primary_key => sub_res_ids}, relevant_options)
+            found = klass.find({klass._primary_key => sub_res_ids}, context: options[:context])
             target_resources[klass.name].merge! found.map{|r| [r.id, r] }.to_h
           end
 

data/lib/jsonapi/resource_serializer.rb

@@ -50,15 +50,35 @@ module JSONAPI
 
       @included_objects = {}
 
-      process_primary(source, @include_directives.include_directives)
+      process_source_objects(source, @include_directives.include_directives)
 
-      included_objects = []
       primary_objects = []
+
+      # pull the processed objects corresponding to the source objects. Ensures we preserve order.
+      if is_resource_collection
+        source.each do |primary|
+          if primary.id
+            case primary
+              when CachedResourceFragment then primary_objects.push(@included_objects[primary.type][primary.id][:object_hash])
+              when Resource then primary_objects.push(@included_objects[primary.class._type][primary.id][:object_hash])
+              else raise "Unknown source type #{primary.inspect}"
+            end
+          end
+        end
+      else
+        if source.try(:id)
+          case source
+            when CachedResourceFragment then primary_objects.push(@included_objects[source.type][source.id][:object_hash])
+            when Resource then primary_objects.push(@included_objects[source.class._type][source.id][:object_hash])
+            else raise "Unknown source type #{source.inspect}"
+          end
+        end
+      end
+
+      included_objects = []
       @included_objects.each_value do |objects|
         objects.each_value do |object|
-          if object[:primary]
-            primary_objects.push(object[:object_hash])
-          else
+          unless object[:primary]
             included_objects.push(object[:object_hash])
           end
         end
@@ -168,9 +188,9 @@ module JSONAPI
     # requested includes. Fields are controlled fields option for each resource type, such
     # as fields: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
     # The fields options controls both fields and included links references.
-    def process_primary(source, include_directives)
+    def process_source_objects(source, include_directives)
       if source.respond_to?(:to_ary)
-        source.each { |resource| process_primary(resource, include_directives) }
+        source.each { |resource| process_source_objects(resource, include_directives) }
       else
         return {} if source.nil?
         add_resource(source, include_directives, true)
@@ -298,8 +318,11 @@ module JSONAPI
       h = source.relationships || {}
       return h unless include_directives.has_key?(:include_related)
 
-      relationships = source.resource_klass._relationships.select{|k,v| source.fetchable_fields.include?(k) }
+      relationships = source.resource_klass._relationships.select do |k,v|
+        source.fetchable_fields.include?(k)
+      end
 
+      real_res = nil
       relationships.each do |rel_name, relationship|
         key = @key_formatter.format(rel_name)
         to_many = relationship.is_a? JSONAPI::Relationship::ToMany
@@ -310,7 +333,17 @@ module JSONAPI
             h[key][:data] = to_many ? [] : nil
           end
 
-          source.preloaded_fragments[key].each do |id, f|
+          fragments = source.preloaded_fragments[key]
+          if fragments.nil?
+            # The resources we want were not preloaded, we'll have to bypass the cache.
+            # This happens when including through belongs_to polymorphic relationships
+            if real_res.nil?
+              real_res = source.to_real_resource
+            end
+            relation_resources = [real_res.public_send(rel_name)].flatten(1).compact
+            fragments = relation_resources.map{|r| [r.id, r]}.to_h
+          end
+          fragments.each do |id, f|
             add_resource(f, ia)
 
             if h.has_key?(key)

data/lib/jsonapi/resources/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Resources
-    VERSION = '0.9.0.beta1'
+    VERSION = '0.9.0.beta2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.9.0.beta1
+  version: 0.9.0.beta2
 platform: ruby
 authors:
 - Dan Gebhardt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-11 00:00:00.000000000 Z
+date: 2017-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -217,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Easily support JSON API in Rails.