Merge branch 'master' into pr/1041

# Conflicts:
#	lib/jsonapi/active_record_accessor.rb

Author: lgebhardt

.travis.yml

@@ -1,19 +1,22 @@
 language: ruby
 sudo: false
 env:
-  - "RAILS_VERSION=4.2.7"
-  - "RAILS_VERSION=5.0.0"
+  - "RAILS_VERSION=4.2.8"
+  - "RAILS_VERSION=5.0.2"
+  - "RAILS_VERSION=5.1.0"
   - "RAILS_VERSION=master"
 rvm:
   - 2.1.10
-  - 2.2.6
-  - 2.3.3
+  - 2.2.7
+  - 2.3.4
   - 2.4.1
 matrix:
   exclude:
     - rvm: 2.1.10
-      env: "RAILS_VERSION=5.0.0"
-    - rvm: 2.4.1
-      env: "RAILS_VERSION=4.2.7"
+      env: "RAILS_VERSION=5.0.2"
+    - rvm: 2.1.10
+      env: "RAILS_VERSION=5.1.0"
+    - rvm: 2.1.10
+      env: "RAILS_VERSION=master"
   allow_failures:
     - env: "RAILS_VERSION=master"

LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Larry Gebhardt
+Copyright (c) 2014-2017 Cerebris Corporation
 
 MIT License
 

README.md

@@ -64,4 +64,4 @@ and **paste the content into the issue description**:
 
 ## License
 
-Copyright 2014-2016 Cerebris Corporation. MIT License (see LICENSE for details).
+Copyright 2014-2017 Cerebris Corporation. MIT License (see LICENSE for details).

Rakefile

@@ -8,11 +8,28 @@ Rake::TestTask.new do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task default: :test
+task default: [:test]
 
 desc 'Run benchmarks'
 namespace :test do
   Rake::TestTask.new(:benchmark) do |t|
     t.pattern = 'test/benchmark/*_benchmark.rb'
   end
 end
+
+desc 'Test bug report template'
+namespace :test do
+  namespace :bug_report_template do
+    task :rails_5 do
+      puts 'Test bug report templates'
+      jsonapi_resources_root = File.expand_path('..', __FILE__)
+      chdir_path = File.join(jsonapi_resources_root, 'lib', 'bug_report_templates')
+      report_env = {'SILENT' => 'true', 'JSONAPI_RESOURCES_PATH' => jsonapi_resources_root}
+      Bundler.with_clean_env do
+        Dir.chdir(chdir_path) do
+          abort('bug report template rails_5_master fails') unless system(report_env, Gem.ruby, 'rails_5_master.rb')
+        end
+      end
+    end
+  end
+end

lib/bug_report_templates/rails_5_master.rb

@@ -1,11 +1,12 @@
 begin
   require 'bundler/inline'
+  require 'bundler'
 rescue LoadError => e
   STDERR.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
   raise e
 end
 
-gemfile(true) do
+gemfile(true, ui: ENV['SILENT'] ? Bundler::UI::Silent.new : Bundler::UI::Shell.new) do
   source 'https://rubygems.org'
 
   gem 'rails', require: false
@@ -27,8 +28,17 @@
 # prepare active_record database
 require 'active_record'
 
+class NullLogger < Logger
+  def initialize(*_args)
+  end
+
+  def add(*_args, &_block)
+  end
+end
+
 ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.logger = ENV['SILENT'] ? NullLogger.new : Logger.new(STDOUT)
+ActiveRecord::Migration.verbose = !ENV['SILENT']
 
 ActiveRecord::Schema.define do
   # Add your schema here
@@ -61,7 +71,7 @@ class YourModelResource < JSONAPI::Resource
 
 class TestApp < Rails::Application
   config.root = File.dirname(__FILE__)
-  config.logger = Logger.new(STDOUT)
+  config.logger = ENV['SILENT'] ? NullLogger.new : Logger.new(STDOUT)
   Rails.logger = config.logger
 
   secrets.secret_token = 'secret_token'

lib/jsonapi/active_record_accessor.rb

@@ -231,6 +231,7 @@ def default_sort(records, order_options)
             order_by_query = "#{associations.last.name}_sorting.#{column_name} #{direction}"
             records = records.joins(joins_query).order(order_by_query)
           else
+            field = _resource_klass._attribute_delegated_name(field)
             records = records.order(field => direction)
           end
         end
@@ -279,6 +280,7 @@ def apply_filter(records, filter, value, options = {})
             records.where("#{_resource_klass._relationships[filter].table_name}.#{_resource_klass._relationships[filter].primary_key}" => value)
           end
         else
+          filter = _resource_klass._attribute_delegated_name(filter)
           records.where(filter => value)
         end
       end

lib/jsonapi/include_directives.rb

@@ -52,7 +52,7 @@ def get_related(current_path)
           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}."
+          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

lib/jsonapi/relationship.rb

@@ -64,6 +64,10 @@ def readonly?
       @options[:readonly]
     end
 
+    def redefined_pkey?
+      belongs_to? && primary_key != resource_klass._default_primary_key
+    end
+
     class ToOne < Relationship
       attr_reader :foreign_key_on
 

lib/jsonapi/request_parser.rb

@@ -281,7 +281,6 @@ def parse_fields(resource_klass, fields)
         fail JSONAPI::Exceptions::InvalidFieldFormat.new(error_object_overrides)
       end
 
-      errors = []
       # Validate the fields
       validated_fields = {}
       extracted_fields.each do |type, values|
@@ -293,31 +292,27 @@ def parse_fields(resource_klass, fields)
           end
           type_resource = Resource.resource_klass_for(resource_klass.module_path + underscored_type.to_s)
         rescue NameError
-          errors.concat(JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides).errors)
-        rescue JSONAPI::Exceptions::InvalidResource => e
-          errors.concat(e.errors)
+          fail JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides)
         end
 
         if type_resource.nil?
-          errors.concat(JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides).errors)
+          fail JSONAPI::Exceptions::InvalidResource.new(type, error_object_overrides)
         else
           unless values.nil?
             valid_fields = type_resource.fields.collect { |key| format_key(key) }
             values.each do |field|
               if valid_fields.include?(field)
                 validated_fields[type].push unformat_key(field)
               else
-                errors.concat(JSONAPI::Exceptions::InvalidField.new(type, field, error_object_overrides).errors)
+                fail JSONAPI::Exceptions::InvalidField.new(type, field, error_object_overrides)
               end
             end
           else
-            errors.concat(JSONAPI::Exceptions::InvalidField.new(type, 'nil', error_object_overrides).errors)
+            fail JSONAPI::Exceptions::InvalidField.new(type, 'nil', error_object_overrides)
           end
         end
       end
 
-      fail JSONAPI::Exceptions::Errors.new(errors) unless errors.empty?
-
       validated_fields.deep_transform_keys { |key| unformat_key(key) }
     end
 
@@ -331,8 +326,7 @@ def check_include(resource_klass, include_parts)
                         include_parts.last.partition('.'))
         end
       else
-        @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
-                                                               include_parts.first).errors)
+        fail JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type), include_parts.first)
       end
     end
 
@@ -352,12 +346,17 @@ def parse_include_directives(resource_klass, raw_include)
 
       return if included_resources.nil?
 
-      result = included_resources.compact.map do |included_resource|
-        check_include(resource_klass, included_resource.partition('.'))
-        unformat_key(included_resource).to_s
-      end
+      begin
+        result = included_resources.compact.map do |included_resource|
+          check_include(resource_klass, included_resource.partition('.'))
+          unformat_key(included_resource).to_s
+        end
 
-      JSONAPI::IncludeDirectives.new(resource_klass, result)
+        return JSONAPI::IncludeDirectives.new(resource_klass, result)
+      rescue JSONAPI::Exceptions::InvalidInclude => e
+        @errors.concat(e.errors)
+        return {}
+      end
     end
 
     def parse_filters(resource_klass, filters)
@@ -385,7 +384,7 @@ def parse_filters(resource_klass, filters)
         if resource_klass._allowed_filter?(filter)
           parsed_filters[filter] = value
         else
-          @errors.concat(JSONAPI::Exceptions::FilterNotAllowed.new(filter).errors)
+          fail JSONAPI::Exceptions::FilterNotAllowed.new(filter)
         end
       end
 
@@ -428,8 +427,7 @@ def check_sort_criteria(resource_klass, sort_criteria)
       sort_field = sort_criteria[:field]
 
       unless resource_klass.sortable_field?(sort_field.to_sym, context)
-        @errors.concat(JSONAPI::Exceptions::InvalidSortCriteria
-                           .new(format_key(resource_klass._type), sort_field).errors)
+        fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(resource_klass._type), sort_field)
       end
     end
 
@@ -578,16 +576,14 @@ def unformat_value(resource_klass, attribute, value)
     def verify_permitted_params(params, allowed_fields)
       formatted_allowed_fields = allowed_fields.collect { |field| format_key(field).to_sym }
       params_not_allowed = []
-      param_errors = []
 
       params.each do |key, value|
         case key.to_s
           when 'relationships'
             value.keys.each do |links_key|
               unless formatted_allowed_fields.include?(links_key.to_sym)
                 if JSONAPI.configuration.raise_if_parameters_not_allowed
-                  param_errors.concat JSONAPI::Exceptions::ParameterNotAllowed.new(
-                      links_key, error_object_overrides).errors
+                  fail JSONAPI::Exceptions::ParameterNotAllowed.new(links_key, error_object_overrides)
                 else
                   params_not_allowed.push(links_key)
                   value.delete links_key
@@ -598,8 +594,7 @@ def verify_permitted_params(params, allowed_fields)
             value.each do |attr_key, _attr_value|
               unless formatted_allowed_fields.include?(attr_key.to_sym)
                 if JSONAPI.configuration.raise_if_parameters_not_allowed
-                  param_errors.concat JSONAPI::Exceptions::ParameterNotAllowed.new(
-                      attr_key, error_object_overrides).errors
+                  fail JSONAPI::Exceptions::ParameterNotAllowed.new(attr_key, error_object_overrides)
                 else
                   params_not_allowed.push(attr_key)
                   value.delete attr_key
@@ -610,27 +605,23 @@ def verify_permitted_params(params, allowed_fields)
           when 'id'
             unless formatted_allowed_fields.include?(:id)
               if JSONAPI.configuration.raise_if_parameters_not_allowed
-                param_errors.concat JSONAPI::Exceptions::ParameterNotAllowed.new(
-                    :id, error_object_overrides).errors
+                fail JSONAPI::Exceptions::ParameterNotAllowed.new(:id, error_object_overrides)
               else
                 params_not_allowed.push(:id)
                 params.delete :id
               end
             end
           else
             if JSONAPI.configuration.raise_if_parameters_not_allowed
-              param_errors += JSONAPI::Exceptions::ParameterNotAllowed.new(
-                  key, error_object_overrides).errors
+              fail JSONAPI::Exceptions::ParameterNotAllowed.new(key, error_object_overrides)
             else
               params_not_allowed.push(key)
               params.delete key
             end
         end
       end
 
-      if param_errors.length > 0
-        fail JSONAPI::Exceptions::Errors.new(param_errors)
-      elsif params_not_allowed.length > 0
+      if params_not_allowed.length > 0
         params_not_allowed_warnings = params_not_allowed.map do |param|
           JSONAPI::Warning.new(code: JSONAPI::PARAM_NOT_ALLOWED,
                                title: 'Param not allowed',

lib/jsonapi/resource.rb

@@ -757,6 +757,10 @@ def _attribute_options(attr)
         default_attribute_options.merge(@_attributes[attr])
       end
 
+      def _attribute_delegated_name(attr)
+        @_attributes.fetch(attr.to_sym, {}).fetch(:delegate, attr)
+      end
+
       def _updatable_attributes
         _attributes.map { |key, options| key unless options[:readonly] }.compact
       end
@@ -783,7 +787,11 @@ def _model_name
       end
 
       def _primary_key
-        @_primary_key ||= _model_class.respond_to?(:primary_key) ? _model_class.primary_key : :id
+        @_primary_key ||= _default_primary_key
+      end
+
+      def _default_primary_key
+        @_default_primary_key ||=_model_class.respond_to?(:primary_key) ? _model_class.primary_key : :id
       end
 
       def _cache_field