some clenaup

Author: NullVoxPopuli

lib/active_model_serializers/adapter/json_api/deserialization.rb

@@ -74,105 +74,22 @@ module Deserialization
         #     # }
         #
         def parse!(document, options = {})
-          parse(document, options) do |invalid_payload, reason|
-            fail JSONAPI::Parser::InvalidDocument, "Invalid payload (#{reason}): #{invalid_payload}"
+          parse(document, options) do |exception|
+            raise exception
           end
         end
 
         # Same as parse!, but returns an empty hash instead of raising InvalidDocument
         # on invalid payloads.
         def parse(document, options = {})
-          JSONAPI.parse_response!(document)
-          document = document.to_h
-          puts document
-          return JSONAPI::Deserializable::Resource.new(document)
-          #
-          # primary_data = document['data']
-          #
-          # # null data is allowed, as per the JSON API Schema
-          # return {} unless primary_data
-          #
-          # attributes = primary_data['attributes'] || {}
-          # attributes['id'] = primary_data['id'] if primary_data['id']
-          # relationships = primary_data['relationships'] || {}
-          #
-          # filter_fields(attributes, options)
-          # filter_fields(relationships, options)
-          #
-          # hash = {}
-          # hash.merge!(parse_attributes(attributes, options))
-          # hash.merge!(parse_relationships(relationships, options))
-          #
-          # hash
+          # TODO: change to jsonapi-ralis to have default conversion to flat hashes
+          JSONAPI::Deserializable::Resource.new(document).to_h
         rescue JSONAPI::Parser::InvalidDocument => e
-          puts e.message
           return {} unless block_given?
-          yield
-        end
-
-        # @api private
-        def filter_fields(fields, options)
-          if (only = options[:only])
-            fields.slice!(*Array(only).map(&:to_s))
-          elsif (except = options[:except])
-            fields.except!(*Array(except).map(&:to_s))
-          end
-        end
-
-        # @api private
-        def field_key(field, options)
-          (options[:keys] || {}).fetch(field.to_sym, field).to_sym
-        end
-
-        # @api private
-        def parse_attributes(attributes, options)
-          transform_keys(attributes, options)
-            .map { |(k, v)| { field_key(k, options) => v } }
-            .reduce({}, :merge)
-        end
-
-        # Given an association name, and a relationship data attribute, build a hash
-        # mapping the corresponding ActiveRecord attribute to the corresponding value.
-        #
-        # @example
-        #   parse_relationship(:comments, [{ 'id' => '1', 'type' => 'comments' },
-        #                                  { 'id' => '2', 'type' => 'comments' }],
-        #                                 {})
-        #    # => { :comment_ids => ['1', '2'] }
-        #   parse_relationship(:author, { 'id' => '1', 'type' => 'users' }, {})
-        #    # => { :author_id => '1' }
-        #   parse_relationship(:author, nil, {})
-        #    # => { :author_id => nil }
-        # @param [Symbol] assoc_name
-        # @param [Hash] assoc_data
-        # @param [Hash] options
-        # @return [Hash{Symbol, Object}]
-        #
-        # @api private
-        def parse_relationship(assoc_name, assoc_data, options)
-          prefix_key = field_key(assoc_name, options).to_s.singularize
-          hash =
-            if assoc_data.is_a?(Array)
-              { "#{prefix_key}_ids".to_sym => assoc_data.map { |ri| ri['id'] } }
-            else
-              { "#{prefix_key}_id".to_sym => assoc_data ? assoc_data['id'] : nil }
-            end
-
-          polymorphic = (options[:polymorphic] || []).include?(assoc_name.to_sym)
-          if polymorphic
-            hash["#{prefix_key}_type".to_sym] = assoc_data.present? ? assoc_data['type'] : nil
-          end
-
-          hash
-        end
-
-        # @api private
-        def parse_relationships(relationships, options)
-          transform_keys(relationships, options)
-            .map { |(k, v)| parse_relationship(k, v['data'], options) }
-            .reduce({}, :merge)
+          yield e
         end
 
+        # TODO: transform the keys after parsing
         # @api private
         def transform_keys(hash, options)
           transform = options[:key_transform] || :underscore

test/adapter/json_api/parse_test.rb

@@ -66,11 +66,6 @@ def test_illformed_payloads_safe
             end
           end
 
-          test 'null data is allow per the JSON API Schema' do
-            parsed_hash = ActiveModelSerializers::Adapter::JsonApi::Deserialization.parse!('data' => nil)
-            assert_equal({}, parsed_hash)
-          end
-
           def test_illformed_payloads_unsafe
             @illformed_payloads.each do |p|
               assert_raises(JSONAPI::Parser::InvalidDocument) do