RFC: Json Api Errors (WIP)

Author: bf4

lib/active_model/serializer.rb

@@ -6,6 +6,7 @@ class Serializer
 
     autoload :Configuration
     autoload :ArraySerializer
+    autoload :ErrorSerializer
     autoload :Adapter
     autoload :Lint
     autoload :Associations

lib/active_model/serializer/adapter/flatten_json.rb

@@ -2,7 +2,7 @@ module ActiveModel
   class Serializer
     class Adapter
       class FlattenJson < Json
-        def serializable_hash(options = {})
+        def serializable_hash(options = nil)
           super
           @result
         end

lib/active_model/serializer/adapter/json_api.rb

@@ -1,5 +1,6 @@
 require 'active_model/serializer/adapter/json_api/fragment_cache'
 require 'active_model/serializer/adapter/json_api/pagination_links'
+require 'active_model/serializer/adapter/json_api/error'
 
 module ActiveModel
   class Serializer

lib/active_model/serializer/adapter/json_api/error.rb

@@ -0,0 +1,36 @@
+class ActiveModel::Serializer::Adapter::JsonApi::Error < ActiveModel::Serializer::Adapter
+  def serializable_hash(options = nil)
+    options ||= {}
+
+
+    @result = []
+    object_errors.each do |attribute_name, attribute_errors|
+      attribute_errors.each do |attribute_error|
+        @result << {
+          source: { pointer: "data/attributes/#{attribute_name}" },
+          detail: attribute_error,
+        }
+      end
+    end
+
+    { root => @result }
+
+    @result
+  end
+
+  def fragment_cache(cached_hash, non_cached_hash)
+    Json::FragmentCache.new().fragment_cache(cached_hash, non_cached_hash)
+  end
+
+  def root
+    "errors".freeze
+  end
+
+  private
+
+  def object_errors
+    cache_check(serializer) do
+      serializer.object.errors.messages
+    end
+  end
+end

lib/active_model/serializer/error_serializer.rb

@@ -0,0 +1,2 @@
+class ActiveModel::Serializer::ErrorSerializer < ActiveModel::Serializer
+end

lib/active_model/serializer/lint.rb

@@ -36,7 +36,17 @@ def test_serializable_hash
     # Typically, it is implemented by including ActiveModel::Serialization.
     def test_read_attribute_for_serialization
       assert_respond_to resource, :read_attribute_for_serialization, "The resource should respond to read_attribute_for_serialization"
-      assert_equal resource.method(:read_attribute_for_serialization).arity, 1
+      actual_arity = resource.method(:read_attribute_for_serialization).arity
+      if defined?(::Rubinius)
+        #  1 for def read_attribute_for_serialization(name); end
+        # -2 for alias :read_attribute_for_serialization :send for rbx because :shrug:
+        assert_includes [1, -2], actual_arity, "expected #{actual_arity.inspect} to be 1 or -2"
+      else
+        # using absolute value since arity is:
+        #  1 for def read_attribute_for_serialization(name); end
+        # -1 for alias :read_attribute_for_serialization :send
+        assert_includes [1, -1], actual_arity, "expected #{actual_arity.inspect} to be 1 or -1"
+      end
     end
 
     # Passes if the object responds to <tt>as_json</tt> and if it takes

test/adapter/json_api/errors_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+=begin
+## http://jsonapi.org/format/#document-top-level
+
+A document MUST contain at least one of the following top-level members:
+
+- data: the document's "primary data"
+- errors: an array of error objects
+- meta: a meta object that contains non-standard meta-information.
+
+The members data and errors MUST NOT coexist in the same document.
+
+## http://jsonapi.org/format/#error-objects
+
+Error objects provide additional information about problems encountered while performing an operation. Error objects MUST be returned as an array keyed by errors in the top level of a JSON API document.
+
+An error object MAY have the following members:
+
+- id: a unique identifier for this particular occurrence of the problem.
+- links: a links object containing the following members:
+  - about: a link that leads to further details about this particular occurrence of the problem.
+- status: the HTTP status code applicable to this problem, expressed as a string value.
+- code: an application-specific error code, expressed as a string value.
+- title: a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of the problem, except for purposes of localization.
+- detail: a human-readable explanation specific to this occurrence of the problem.
+- source: an object containing references to the source of the error, optionally including any of the following members:
+  -  pointer: a JSON Pointer [RFC6901] to the associated entity in the request document [e.g. "/data" for a primary data object, or "/data/attributes/title" for a specific attribute].
+  -  parameter: a string indicating which query parameter caused the error.
+- meta: a meta object containing non-standard meta-information about the error.
+
+=end
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      class JsonApi
+        class ErrorsTest < Minitest::Test
+          include ActiveModel::Serializer::Lint::Tests
+
+          # see
+          # https://github.com/rails/rails/blob/4-2-stable/activemodel/lib/active_model/errors.rb
+          # The below allows you to do:
+          #
+          #   model = ModelWithErrors.new
+          #   model.validate!            # => ["cannot be nil"]
+          #   model.errors.full_messages # => ["name cannot be nil"]
+          class ModelWithErrors
+            include ActiveModel::Serialization
+            def attributes
+              {
+                errors: errors,
+                name: name,
+              }
+            end
+
+            def id
+              object_id
+            end
+
+            def cache_key
+              "#{self.class.name.downcase}/#{id}-#{Time.now.utc.strftime("%Y%m%d%H%M%S%9N")}"
+            end
+
+            # Required dependency for ActiveModel::Errors
+            extend ActiveModel::Naming
+            def initialize
+              @errors = ActiveModel::Errors.new(self)
+            end
+            attr_accessor :name
+            attr_reader   :errors
+
+            # The following methods are needed to be minimally implemented
+
+            def read_attribute_for_validation(attr)
+              send(attr)
+            end
+
+            def self.human_attribute_name(attr, options = {})
+              attr
+            end
+
+            def self.lookup_ancestors
+              [self]
+            end
+          end
+
+          def setup
+            @resource = ModelWithErrors.new
+          end
+
+          def test_active_model_errors
+            options = {
+                serializer: ActiveModel::Serializer::ErrorSerializer,
+                adapter: :'json_api/error',
+            }
+
+            @resource.errors.add(:name, "cannot be nil")
+
+            serializable_resource = ActiveModel::SerializableResource.serialize(@resource, options)
+            assert_equal serializable_resource.serializer_instance.attributes, { }
+            assert_equal serializable_resource.serializer_instance.object, @resource
+
+            expected_errors_object = [
+                {
+                  source: { pointer: 'data/attributes/name' },
+                  detail: 'cannot be nil'
+                }
+            ]
+            assert_equal serializable_resource.as_json, expected_errors_object
+          end
+        end
+      end
+    end
+  end
+end